Full Code of Yangqing/caffe2 for AI

gitextract_2u1ieaci/

├── .gitattributes
├── .github/
│   ├── CONTRIBUTING.md
│   ├── ISSUE_TEMPLATE.md
│   └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── .gitmodules
├── .jenkins/
│   ├── README.md
│   ├── build.sh
│   └── test.sh
├── .travis/
│   ├── build.sh
│   ├── install.sh
│   ├── setup.sh
│   └── test.sh
├── .travis.yml
├── CMakeLists.txt
├── LICENSE
├── Makefile
├── NOTICE
├── README.md
├── VERSION_NUMBER
├── appveyor.yml
├── binaries/
│   ├── CMakeLists.txt
│   ├── caffe2_benchmark.cc
│   ├── convert_caffe_image_db.cc
│   ├── convert_db.cc
│   ├── convert_encoded_to_raw_leveldb.cc
│   ├── core_overhead_benchmark.cc
│   ├── db_throughput.cc
│   ├── inspect_gpus.cc
│   ├── make_cifar_db.cc
│   ├── make_image_db.cc
│   ├── make_mnist_db.cc
│   ├── predictor_verifier.cc
│   ├── print_core_object_sizes.cc
│   ├── print_registered_core_operators.cc
│   ├── run_plan.cc
│   ├── run_plan_mpi.cc
│   ├── speed_benchmark.cc
│   ├── split_db.cc
│   ├── tutorial_blob.cc
│   └── zmq_feeder.cc
├── caffe/
│   ├── __init__.py
│   └── proto/
│       ├── CMakeLists.txt
│       ├── __init__.py
│       └── caffe.proto
├── caffe2/
│   ├── .clang-format
│   ├── CMakeLists.txt
│   ├── __init__.py
│   ├── contrib/
│   │   ├── CMakeLists.txt
│   │   ├── __init__.py
│   │   ├── aten/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── README.md
│   │   │   ├── aten_op.cc
│   │   │   ├── aten_op.h
│   │   │   ├── aten_op_cuda.cc
│   │   │   ├── aten_op_template.h
│   │   │   ├── aten_test.py
│   │   │   ├── docs/
│   │   │   │   ├── pytorch_to_caffe2.md
│   │   │   │   └── sample.py
│   │   │   └── gen_op.py
│   │   ├── cuda-convnet2/
│   │   │   ├── LICENSE
│   │   │   ├── README.md
│   │   │   ├── build.sh
│   │   │   ├── convdata.py
│   │   │   ├── convnet.py
│   │   │   ├── cudaconv3/
│   │   │   │   ├── Makefile
│   │   │   │   ├── include/
│   │   │   │   │   ├── conv_util.cuh
│   │   │   │   │   └── cudaconv2.cuh
│   │   │   │   └── src/
│   │   │   │       ├── conv_util.cu
│   │   │   │       ├── filter_acts.cu
│   │   │   │       ├── img_acts.cu
│   │   │   │       └── weight_acts.cu
│   │   │   ├── cudaconvnet/
│   │   │   │   ├── Makefile
│   │   │   │   ├── __init__.py
│   │   │   │   ├── include/
│   │   │   │   │   ├── actbroadcaster.cuh
│   │   │   │   │   ├── convnet.cuh
│   │   │   │   │   ├── copypipeline.cuh
│   │   │   │   │   ├── cost.cuh
│   │   │   │   │   ├── data.cuh
│   │   │   │   │   ├── gradreducer.cuh
│   │   │   │   │   ├── jpeg.h
│   │   │   │   │   ├── layer.cuh
│   │   │   │   │   ├── layer_kernels.cuh
│   │   │   │   │   ├── lr.cuh
│   │   │   │   │   ├── memorysource.cuh
│   │   │   │   │   ├── messages.cuh
│   │   │   │   │   ├── neuron.cuh
│   │   │   │   │   ├── pipedispenser.cuh
│   │   │   │   │   ├── pyconvnet.cuh
│   │   │   │   │   ├── reducepipeline.cuh
│   │   │   │   │   ├── streambroadcast.cuh
│   │   │   │   │   ├── timer.cuh
│   │   │   │   │   ├── util.cuh
│   │   │   │   │   ├── weights.cuh
│   │   │   │   │   └── worker.cuh
│   │   │   │   └── src/
│   │   │   │       ├── actbroadcaster.cu
│   │   │   │       ├── convnet.cu
│   │   │   │       ├── copypipeline.cu
│   │   │   │       ├── cost.cu
│   │   │   │       ├── data.cu
│   │   │   │       ├── gradreducer.cu
│   │   │   │       ├── jpeg.cpp
│   │   │   │       ├── layer.cu
│   │   │   │       ├── layer_kernels.cu
│   │   │   │       ├── lr.cu
│   │   │   │       ├── memorysource.cu
│   │   │   │       ├── neuron.cu
│   │   │   │       ├── pyconvnet.cu
│   │   │   │       ├── reducepipeline.cu
│   │   │   │       ├── streambroadcast.cu
│   │   │   │       ├── util.cu
│   │   │   │       ├── weights.cu
│   │   │   │       └── worker.cu
│   │   │   ├── initw.py
│   │   │   ├── layer.py
│   │   │   ├── layers/
│   │   │   │   ├── layer-params-cifar10-11pct.cfg
│   │   │   │   ├── layer-params-imagenet-1gpu.cfg
│   │   │   │   ├── layer-params-imagenet-2gpu-data.cfg
│   │   │   │   ├── layer-params-imagenet-2gpu-model.cfg
│   │   │   │   ├── layer-params-imagenet-4gpu-data-model.cfg
│   │   │   │   ├── layer-params-imagenet-4gpu-data.cfg
│   │   │   │   ├── layers-cifar10-11pct.cfg
│   │   │   │   ├── layers-imagenet-1gpu.cfg
│   │   │   │   ├── layers-imagenet-2gpu-data.cfg
│   │   │   │   ├── layers-imagenet-2gpu-model.cfg
│   │   │   │   ├── layers-imagenet-4gpu-data-model.cfg
│   │   │   │   └── layers-imagenet-4gpu-data.cfg
│   │   │   ├── make-data/
│   │   │   │   ├── input_meta
│   │   │   │   ├── make-data.py
│   │   │   │   └── pyext/
│   │   │   │       ├── Makefile
│   │   │   │       ├── __init__.py
│   │   │   │       ├── include/
│   │   │   │       │   └── pyext.h
│   │   │   │       └── src/
│   │   │   │           └── pyext.cpp
│   │   │   ├── nvmatrix/
│   │   │   │   ├── Makefile
│   │   │   │   ├── include/
│   │   │   │   │   ├── memory.cuh
│   │   │   │   │   ├── nvmatrix.cuh
│   │   │   │   │   ├── nvmatrix_kernels.cuh
│   │   │   │   │   └── nvmatrix_operators.cuh
│   │   │   │   └── src/
│   │   │   │       ├── memory.cu
│   │   │   │       ├── nvmatrix.cu
│   │   │   │       └── nvmatrix_kernels.cu
│   │   │   ├── python_util/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── data.py
│   │   │   │   ├── gpumodel.py
│   │   │   │   ├── options.py
│   │   │   │   └── util.py
│   │   │   ├── shownet.py
│   │   │   └── util/
│   │   │       ├── Makefile
│   │   │       ├── include/
│   │   │       │   ├── matrix.h
│   │   │       │   ├── matrix_funcs.h
│   │   │       │   ├── queue.h
│   │   │       │   ├── sync.h
│   │   │       │   └── thread.h
│   │   │       └── src/
│   │   │           └── matrix.cpp
│   │   ├── docker-ubuntu-14.04/
│   │   │   └── Dockerfile
│   │   ├── gloo/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── allgather_ops.cc
│   │   │   ├── allgather_ops.h
│   │   │   ├── allreduce_ops.cc
│   │   │   ├── allreduce_ops.h
│   │   │   ├── allreduce_ops_gpu.cc
│   │   │   ├── barrier_ops.cc
│   │   │   ├── barrier_ops.h
│   │   │   ├── broadcast_ops.cc
│   │   │   ├── broadcast_ops.h
│   │   │   ├── broadcast_ops_gpu.cc
│   │   │   ├── common.cc
│   │   │   ├── common.h
│   │   │   ├── common_world_ops.cc
│   │   │   ├── common_world_ops.h
│   │   │   ├── common_world_ops_gpu.cc
│   │   │   ├── context.cc
│   │   │   ├── context.h
│   │   │   ├── gloo_test.py
│   │   │   ├── py_export.cc
│   │   │   ├── reduce_scatter_ops.cc
│   │   │   ├── reduce_scatter_ops.h
│   │   │   ├── store_handler.cc
│   │   │   └── store_handler.h
│   │   ├── nccl/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── cuda_nccl_gpu.cc
│   │   │   ├── cuda_nccl_gpu.h
│   │   │   ├── cuda_nccl_op_gpu.cc
│   │   │   └── nccl_ops_test.py
│   │   ├── nervana/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── nervana.h
│   │   │   ├── nervana_c_api.cu
│   │   │   ├── nervana_c_api.h
│   │   │   ├── nervana_fc_op_gpu.cc
│   │   │   ├── nervana_fc_op_gpu_test.cc
│   │   │   ├── nervana_init_gpu.cc
│   │   │   └── nervana_math_gpu.cc
│   │   ├── nnpack/
│   │   │   ├── nnpack_ops.cc
│   │   │   └── nnpack_ops_test.py
│   │   ├── playground/
│   │   │   ├── AnyExp.py
│   │   │   ├── AnyExpOnTerm.py
│   │   │   ├── ModuleRegister.py
│   │   │   ├── README.md
│   │   │   ├── __init__.py
│   │   │   ├── checkpoint.py
│   │   │   ├── compute_loss.py
│   │   │   ├── compute_topk_accuracy.py
│   │   │   ├── meter.py
│   │   │   ├── module_map.py
│   │   │   ├── output_generator.py
│   │   │   └── resnet50demo/
│   │   │       ├── IN1k_resnet50.py
│   │   │       ├── __init__.py
│   │   │       ├── caffe2_resnet50_default_forward.py
│   │   │       ├── caffe2_resnet50_default_param_update.py
│   │   │       ├── explicit_resnet_forward.py
│   │   │       ├── explicit_resnet_param_update.py
│   │   │       ├── gfs_IN1k.py
│   │   │       └── rendezvous_filestore.py
│   │   ├── prof/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── cuda_profile_ops.cc
│   │   │   ├── cuda_profile_ops_test.py
│   │   │   ├── htrace_async_dag_net_gpu.cc
│   │   │   ├── htrace_conf.cc
│   │   │   ├── htrace_conf.h
│   │   │   ├── htrace_dag_net.cc
│   │   │   ├── htrace_to_chrome.py
│   │   │   ├── prof_dag_net.cc
│   │   │   ├── prof_dag_net.h
│   │   │   ├── prof_dag_stats_op.cc
│   │   │   └── prof_dag_stats_op.h
│   │   ├── script/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── caffe2_script_test.py
│   │   │   ├── compiler.cc
│   │   │   ├── compiler.h
│   │   │   ├── error_report.h
│   │   │   ├── examples/
│   │   │   │   ├── example_beam_search.c2s
│   │   │   │   ├── example_post_eos_penalty.c2s
│   │   │   │   └── run_examples.py
│   │   │   ├── lexer.cc
│   │   │   ├── lexer.h
│   │   │   ├── parser.h
│   │   │   ├── tree.h
│   │   │   └── tree_views.h
│   │   ├── shm_mutex/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── shm_mutex.cc
│   │   │   └── shm_mutex.h
│   │   ├── tensorboard/
│   │   │   ├── __init__.py
│   │   │   ├── tensorboard.md
│   │   │   ├── tensorboard.py
│   │   │   ├── tensorboard_exporter.py
│   │   │   ├── tensorboard_exporter_test.py
│   │   │   └── tensorboard_test.py
│   │   ├── torch/
│   │   │   ├── th_ops.cc
│   │   │   ├── th_ops_gpu.cu
│   │   │   ├── th_ops_test.py
│   │   │   ├── torch_op.cpp
│   │   │   ├── torch_op.h
│   │   │   ├── torch_op_gpu.cpp
│   │   │   └── torch_ops_test.py
│   │   └── warpctc/
│   │       ├── ctc_op.cpp
│   │       ├── ctc_op.h
│   │       ├── ctc_op_gpu.cpp
│   │       └── ctc_ops_test.py
│   ├── core/
│   │   ├── CMakeLists.txt
│   │   ├── allocator.cc
│   │   ├── allocator.h
│   │   ├── asan.h
│   │   ├── blob.h
│   │   ├── blob_gpu_test.cc
│   │   ├── blob_serialization.cc
│   │   ├── blob_serialization.h
│   │   ├── blob_serialization_gpu.cc
│   │   ├── blob_serializer_base.h
│   │   ├── blob_stats.cc
│   │   ├── blob_stats.h
│   │   ├── blob_test.cc
│   │   ├── common.cc
│   │   ├── common.h
│   │   ├── common_cudnn.cc
│   │   ├── common_cudnn.h
│   │   ├── common_gpu.cc
│   │   ├── common_gpu.h
│   │   ├── common_omp.h
│   │   ├── common_test.cc
│   │   ├── context.cc
│   │   ├── context.h
│   │   ├── context_gpu.cu
│   │   ├── context_gpu.h
│   │   ├── context_gpu_test.cc
│   │   ├── context_test.cc
│   │   ├── cudnn_wrappers.h
│   │   ├── db.cc
│   │   ├── db.h
│   │   ├── event.cc
│   │   ├── event.h
│   │   ├── event_cpu.h
│   │   ├── event_gpu.cc
│   │   ├── event_gpu_test.cc
│   │   ├── event_test.cc
│   │   ├── flags.cc
│   │   ├── flags.h
│   │   ├── graph.cc
│   │   ├── graph.h
│   │   ├── graph_test.cc
│   │   ├── init.cc
│   │   ├── init.h
│   │   ├── init_intrinsics_check.cc
│   │   ├── init_omp.cc
│   │   ├── init_test.cc
│   │   ├── logging.cc
│   │   ├── logging.h
│   │   ├── logging_is_google_glog.h
│   │   ├── logging_is_not_google_glog.h
│   │   ├── logging_test.cc
│   │   ├── macros.h
│   │   ├── macros.h.in
│   │   ├── memonger.cc
│   │   ├── memonger.h
│   │   ├── module.cc
│   │   ├── module.h
│   │   ├── module_test.cc
│   │   ├── net.cc
│   │   ├── net.h
│   │   ├── net_async_base.cc
│   │   ├── net_async_base.h
│   │   ├── net_async_dag_gpu.cc
│   │   ├── net_async_dag_gpu.h
│   │   ├── net_async_gpu_thread_pool.h
│   │   ├── net_async_gpu_thread_pool_gpu.cc
│   │   ├── net_async_polling.cc
│   │   ├── net_async_polling.h
│   │   ├── net_async_scheduling.cc
│   │   ├── net_async_scheduling.h
│   │   ├── net_dag.cc
│   │   ├── net_dag.h
│   │   ├── net_dag_utils.cc
│   │   ├── net_dag_utils.h
│   │   ├── net_gpu_test.cc
│   │   ├── net_simple.cc
│   │   ├── net_simple.h
│   │   ├── net_simple_async.cc
│   │   ├── net_simple_async.h
│   │   ├── net_singlethread_async_gpu.cc
│   │   ├── net_test.cc
│   │   ├── numa.cc
│   │   ├── numa.h
│   │   ├── observer.h
│   │   ├── observer_test.cc
│   │   ├── operator.cc
│   │   ├── operator.h
│   │   ├── operator_gpu_test.cc
│   │   ├── operator_gradient.h
│   │   ├── operator_schema.cc
│   │   ├── operator_schema.h
│   │   ├── operator_schema_test.cc
│   │   ├── operator_test.cc
│   │   ├── parallel_net_test.cc
│   │   ├── plan_executor.cc
│   │   ├── plan_executor.h
│   │   ├── predictor.cc
│   │   ├── predictor.h
│   │   ├── predictor_test.cc
│   │   ├── qtensor.cc
│   │   ├── qtensor.h
│   │   ├── qtensor_serialization.cc
│   │   ├── qtensor_serialization.h
│   │   ├── registry.h
│   │   ├── registry_test.cc
│   │   ├── scope_guard.h
│   │   ├── static_tracepoint.h
│   │   ├── static_tracepoint_elfx86.h
│   │   ├── stats.cc
│   │   ├── stats.h
│   │   ├── stats_test.cc
│   │   ├── tensor.cc
│   │   ├── tensor.h
│   │   ├── timer.h
│   │   ├── timer_test.cc
│   │   ├── transform.cc
│   │   ├── transform.h
│   │   ├── transform_test.cc
│   │   ├── typeid.cc
│   │   ├── typeid.h
│   │   ├── typeid_test.cc
│   │   ├── types.cc
│   │   ├── types.h
│   │   ├── workspace.cc
│   │   ├── workspace.h
│   │   └── workspace_test.cc
│   ├── cuda_rtc/
│   │   ├── CMakeLists.txt
│   │   ├── common_rtc.h
│   │   ├── elemenntwise_rtc_gpu.cc
│   │   └── pool_op_rtc_gpu.cc
│   ├── db/
│   │   ├── CMakeLists.txt
│   │   ├── create_db_op.cc
│   │   ├── create_db_op.h
│   │   ├── create_db_op_gpu.cc
│   │   ├── db_test.cc
│   │   ├── leveldb.cc
│   │   ├── lmdb.cc
│   │   ├── protodb.cc
│   │   └── zmqdb.cc
│   ├── distributed/
│   │   ├── CMakeLists.txt
│   │   ├── file_store_handler.cc
│   │   ├── file_store_handler.h
│   │   ├── file_store_handler_op.cc
│   │   ├── file_store_handler_op.h
│   │   ├── file_store_handler_op_gpu.cc
│   │   ├── file_store_handler_op_test.py
│   │   ├── py_export.cc
│   │   ├── redis_store_handler.cc
│   │   ├── redis_store_handler.h
│   │   ├── redis_store_handler_op.cc
│   │   ├── redis_store_handler_op.h
│   │   ├── redis_store_handler_op_gpu.cc
│   │   ├── redis_store_handler_op_test.py
│   │   ├── store_handler.cc
│   │   ├── store_handler.h
│   │   ├── store_ops.cc
│   │   ├── store_ops.h
│   │   └── store_ops_test_util.py
│   ├── experiments/
│   │   ├── operators/
│   │   │   ├── fully_connected_op_decomposition.cc
│   │   │   ├── fully_connected_op_decomposition.h
│   │   │   ├── fully_connected_op_decomposition_gpu.cc
│   │   │   ├── fully_connected_op_prune.cc
│   │   │   ├── fully_connected_op_prune.h
│   │   │   ├── fully_connected_op_sparse.cc
│   │   │   ├── fully_connected_op_sparse.h
│   │   │   ├── funhash_op.cc
│   │   │   ├── funhash_op.h
│   │   │   ├── sparse_funhash_op.cc
│   │   │   ├── sparse_funhash_op.h
│   │   │   ├── sparse_matrix_reshape_op.cc
│   │   │   ├── sparse_matrix_reshape_op.h
│   │   │   ├── tt_contraction_op.cc
│   │   │   ├── tt_contraction_op.h
│   │   │   ├── tt_contraction_op_gpu.cc
│   │   │   ├── tt_pad_op.cc
│   │   │   └── tt_pad_op.h
│   │   └── python/
│   │       ├── SparseTransformer.py
│   │       ├── convnet_benchmarks.py
│   │       ├── device_reduce_sum_bench.py
│   │       ├── funhash_op_test.py
│   │       ├── net_construct_bench.py
│   │       ├── sparse_funhash_op_test.py
│   │       ├── sparse_reshape_op_test.py
│   │       ├── tt_contraction_op_test.py
│   │       └── tt_pad_op_test.py
│   ├── image/
│   │   ├── CMakeLists.txt
│   │   ├── image_input_op.cc
│   │   ├── image_input_op.h
│   │   ├── image_input_op_gpu.cc
│   │   ├── transform_gpu.cu
│   │   └── transform_gpu.h
│   ├── mkl/
│   │   ├── CMakeLists.txt
│   │   ├── mkl_operator.cc
│   │   ├── mkl_utils.h
│   │   ├── mkl_utils_test.cc
│   │   ├── mklmemory_serialization.cc
│   │   ├── mklmemory_serialization_test.cc
│   │   ├── operators/
│   │   │   ├── concat_op.cc
│   │   │   ├── conv_op.cc
│   │   │   ├── conv_op_mkldnn.cc
│   │   │   ├── elementwise_sum_op.cc
│   │   │   ├── fully_connected_op.cc
│   │   │   ├── local_response_normalization_op.cc
│   │   │   ├── operator_fallback_mkl.cc
│   │   │   ├── operator_fallback_mkl.h
│   │   │   ├── packed_fc_op.cc
│   │   │   ├── pool_op.cc
│   │   │   ├── relu_op.cc
│   │   │   ├── spatial_batch_norm_op.cc
│   │   │   ├── squeeze_op.cc
│   │   │   └── utility_ops.cc
│   │   └── utils/
│   │       ├── mkl_context.cc
│   │       ├── mkl_context.h
│   │       ├── mkl_dnn_cppwrapper.h
│   │       ├── mkl_memory.cc
│   │       ├── mkl_memory.h
│   │       ├── mkl_operator.h
│   │       ├── mkl_version_check.h
│   │       └── sgemm_pack.h
│   ├── mobile/
│   │   ├── CMakeLists.txt
│   │   └── contrib/
│   │       ├── CMakeLists.txt
│   │       ├── arm-compute/
│   │       │   ├── CMakeLists.txt
│   │       │   ├── README.md
│   │       │   ├── core/
│   │       │   │   ├── CMakeLists.txt
│   │       │   │   ├── context.cc
│   │       │   │   ├── context.h
│   │       │   │   ├── net_gl.cc
│   │       │   │   ├── net_gl.h
│   │       │   │   ├── operator.cc
│   │       │   │   ├── operator.h
│   │       │   │   ├── rewrite_net.cc
│   │       │   │   └── rewrite_net.h
│   │       │   ├── models/
│   │       │   │   ├── squeezenet_init.pb
│   │       │   │   └── squeezenet_predict.pb
│   │       │   ├── operators/
│   │       │   │   ├── CMakeLists.txt
│   │       │   │   ├── activation_ops.cc
│   │       │   │   ├── activation_ops.h
│   │       │   │   ├── concat_op.cc
│   │       │   │   ├── conv_op.cc
│   │       │   │   ├── copy_op.cc
│   │       │   │   ├── elementwise_sum_op.cc
│   │       │   │   ├── fully_connected_op.cc
│   │       │   │   ├── norm_planar_yuv_op.cc
│   │       │   │   ├── pool_op.cc
│   │       │   │   ├── reshape_op.cc
│   │       │   │   ├── resize_op.cc
│   │       │   │   ├── softmax_op.cc
│   │       │   │   └── spatial_batch_norm_op.cc
│   │       │   ├── run_tests.sh
│   │       │   └── test/
│   │       │       ├── CMakeLists.txt
│   │       │       ├── gl_activation_ops_test.cc
│   │       │       ├── gl_alignment_test.cc
│   │       │       ├── gl_concat_op_test.cc
│   │       │       ├── gl_context_test.cc
│   │       │       ├── gl_conv_op_test.cc
│   │       │       ├── gl_copy_op_test.cc
│   │       │       ├── gl_elementwise_sum_op_test.cc
│   │       │       ├── gl_fully_connected_op_test.cc
│   │       │       ├── gl_model_test.cc
│   │       │       ├── gl_model_test.h
│   │       │       ├── gl_norm_planar_yuv_op_test.cc
│   │       │       ├── gl_operator_test.h
│   │       │       ├── gl_pool_op_test.cc
│   │       │       ├── gl_resize_op_test.cc
│   │       │       ├── gl_softmax_op_test.cc
│   │       │       └── gl_spatial_batch_norm_op_test.cc
│   │       ├── ios/
│   │       │   ├── CMakeLists.txt
│   │       │   ├── ios_caffe.cc
│   │       │   ├── ios_caffe.h
│   │       │   ├── ios_caffe_defines.h
│   │       │   ├── ios_caffe_predictor.cc
│   │       │   ├── ios_caffe_predictor.h
│   │       │   ├── mpscnn/
│   │       │   │   ├── CMakeLists.txt
│   │       │   │   ├── MPSCNN.metal
│   │       │   │   ├── mpscnn.h
│   │       │   │   ├── mpscnn.mm
│   │       │   │   ├── mpscnn_context.h
│   │       │   │   ├── mpscnn_context.mm
│   │       │   │   ├── mpscnn_graph.mm
│   │       │   │   ├── mpscnn_graph_mask.h
│   │       │   │   ├── mpscnn_graph_mask.mm
│   │       │   │   ├── mpscnn_kernels.h
│   │       │   │   ├── mpscnn_test.h
│   │       │   │   └── mpscnn_test.mm
│   │       │   ├── pool_test.cc
│   │       │   └── resize_test.cc
│   │       ├── libopencl-stub/
│   │       │   ├── Android.mk
│   │       │   ├── LICENSE
│   │       │   ├── Makefile
│   │       │   ├── README.md
│   │       │   ├── include/
│   │       │   │   ├── CL/
│   │       │   │   │   ├── cl.h
│   │       │   │   │   ├── cl.hpp
│   │       │   │   │   ├── cl_ext.h
│   │       │   │   │   ├── cl_gl.h
│   │       │   │   │   ├── cl_gl_ext.h
│   │       │   │   │   ├── cl_platform.h
│   │       │   │   │   └── opencl.h
│   │       │   │   └── libopencl.h
│   │       │   └── src/
│   │       │       └── libopencl.c
│   │       ├── libvulkan-stub/
│   │       │   ├── include/
│   │       │   │   ├── libvulkan-stub.h
│   │       │   │   └── vulkan/
│   │       │   │       ├── vk_platform.h
│   │       │   │       └── vulkan.h
│   │       │   └── src/
│   │       │       └── libvulkan-stub.c
│   │       ├── nnapi/
│   │       │   ├── CMakeLists.txt
│   │       │   ├── NeuralNetworks.h
│   │       │   ├── dlnnapi.c
│   │       │   ├── dlnnapi.h
│   │       │   ├── nnapi.cc
│   │       │   ├── nnapi.h
│   │       │   ├── nnapi_benchmark.cc
│   │       │   └── nnapi_test.cc
│   │       ├── opengl/
│   │       │   ├── CMakeLists.txt
│   │       │   ├── android/
│   │       │   │   ├── AndroidGLContext.cc
│   │       │   │   ├── AndroidGLContext.h
│   │       │   │   ├── CMakeLists.txt
│   │       │   │   ├── GLContext.cc
│   │       │   │   ├── GLImageAllocator.cc
│   │       │   │   ├── arm_neon_support.h
│   │       │   │   ├── gl3stub.c
│   │       │   │   └── gl3stub.h
│   │       │   ├── core/
│   │       │   │   ├── CMakeLists.txt
│   │       │   │   ├── DataTransfer.cc
│   │       │   │   ├── DataTransfer.h
│   │       │   │   ├── GL.h
│   │       │   │   ├── GLContext.cc
│   │       │   │   ├── GLContext.h
│   │       │   │   ├── GLFilter.cc
│   │       │   │   ├── GLFilter.h
│   │       │   │   ├── GLImage.cc
│   │       │   │   ├── GLImage.h
│   │       │   │   ├── GLImageAllocator.cc
│   │       │   │   ├── GLImageAllocator.h
│   │       │   │   ├── GLLogging.h
│   │       │   │   ├── GLPBO.cc
│   │       │   │   ├── GLPBO.h
│   │       │   │   ├── GLPlainTexture.cc
│   │       │   │   ├── GLPlainTexture.h
│   │       │   │   ├── GLPredictor.cc
│   │       │   │   ├── GLPredictor.h
│   │       │   │   ├── GLTexture.cc
│   │       │   │   ├── GLTexture.h
│   │       │   │   ├── ImageAllocator.h
│   │       │   │   ├── arm_neon_support.h
│   │       │   │   ├── rewrite_net.cc
│   │       │   │   └── rewrite_net.h
│   │       │   ├── ios/
│   │       │   │   ├── CMakeLists.txt
│   │       │   │   ├── GLContext.cc
│   │       │   │   ├── GLImageAllocator.cc
│   │       │   │   ├── IOSGLContext.h
│   │       │   │   ├── IOSGLContext.mm
│   │       │   │   ├── IOSGLImageAllocator.cc
│   │       │   │   ├── IOSGLImageAllocator.h
│   │       │   │   ├── IOSGLTexture.h
│   │       │   │   └── IOSGLTexture.mm
│   │       │   ├── operators/
│   │       │   │   ├── CMakeLists.txt
│   │       │   │   ├── GLAdd.cc
│   │       │   │   ├── GLConcat.cc
│   │       │   │   ├── GLConvolution.cc
│   │       │   │   ├── GLConvolution.h
│   │       │   │   ├── GLCopyOps.cc
│   │       │   │   ├── GLInstanceNorm.cc
│   │       │   │   ├── GLMul.cc
│   │       │   │   ├── GLNormPlanarYUV.cc
│   │       │   │   ├── GLPRelu.cc
│   │       │   │   ├── GLPadImage.cc
│   │       │   │   ├── GLPool.cc
│   │       │   │   ├── GLResize.cc
│   │       │   │   ├── GLSigmoid.cc
│   │       │   │   ├── GLSoftmax.cc
│   │       │   │   ├── GLStylizer.cc
│   │       │   │   ├── GLSub.cc
│   │       │   │   └── gl_tiling_utils.h
│   │       │   └── test/
│   │       │       ├── TestGLConvolution.cc
│   │       │       ├── TestGLConvolution.h
│   │       │       ├── opengl_test.cc
│   │       │       └── opengl_test.h
│   │       ├── snpe/
│   │       │   ├── CMakeLists.txt
│   │       │   ├── README.md
│   │       │   ├── snpe_ffi.cc
│   │       │   ├── snpe_ffi.h
│   │       │   ├── snpe_globals.cc
│   │       │   ├── snpe_op.cc
│   │       │   └── snpe_op_benchmark.cc
│   │       └── ulp2/
│   │           ├── ulp.cc
│   │           ├── ulp.h
│   │           ├── ulp_neon.cc
│   │           ├── ulp_neon.h
│   │           └── ulp_test.cc
│   ├── mpi/
│   │   ├── CMakeLists.txt
│   │   ├── mpi_common.cc
│   │   ├── mpi_common.h
│   │   ├── mpi_gpu_test.cc
│   │   ├── mpi_ops.cc
│   │   ├── mpi_ops.h
│   │   ├── mpi_ops_gpu.cc
│   │   └── mpi_test.cc
│   ├── observers/
│   │   ├── CMakeLists.txt
│   │   ├── README.md
│   │   ├── operator_attaching_net_observer.h
│   │   ├── runcnt_observer.cc
│   │   ├── runcnt_observer.h
│   │   ├── time_observer.cc
│   │   ├── time_observer.h
│   │   └── time_observer_test.cc
│   ├── onnx/
│   │   ├── CMakeLists.txt
│   │   ├── backend.cc
│   │   ├── backend.h
│   │   ├── backend_rep.cc
│   │   ├── backend_rep.h
│   │   ├── device.cc
│   │   ├── device.h
│   │   ├── helper.cc
│   │   └── helper.h
│   ├── operators/
│   │   ├── CMakeLists.txt
│   │   ├── abs_op.cc
│   │   ├── abs_op.cu
│   │   ├── accumulate_op.cc
│   │   ├── accumulate_op.cu
│   │   ├── accumulate_op.h
│   │   ├── accuracy_op.cc
│   │   ├── accuracy_op.cu
│   │   ├── accuracy_op.h
│   │   ├── apmeter_op.cc
│   │   ├── apmeter_op.h
│   │   ├── assert_op.cc
│   │   ├── assert_op.cu
│   │   ├── assert_op.h
│   │   ├── atomic_ops.cc
│   │   ├── batch_box_cox_op.cc
│   │   ├── batch_box_cox_op.h
│   │   ├── batch_gather_ops.cc
│   │   ├── batch_gather_ops.cu
│   │   ├── batch_gather_ops.h
│   │   ├── batch_matmul_op.cc
│   │   ├── batch_matmul_op.cu
│   │   ├── batch_matmul_op.h
│   │   ├── batch_matmul_op_gpu_test.cc
│   │   ├── batch_matmul_op_test.cc
│   │   ├── batch_sparse_to_dense_op.cc
│   │   ├── batch_sparse_to_dense_op.h
│   │   ├── bbox_transform_op.cc
│   │   ├── bbox_transform_op.h
│   │   ├── boolean_mask_ops.cc
│   │   ├── boolean_mask_ops.cu
│   │   ├── boolean_mask_ops.h
│   │   ├── boolean_unmask_ops.cc
│   │   ├── boolean_unmask_ops.cu
│   │   ├── boolean_unmask_ops.h
│   │   ├── boolean_unmask_ops_test.cc
│   │   ├── box_with_nms_limit_op.cc
│   │   ├── box_with_nms_limit_op.h
│   │   ├── cast_op.cc
│   │   ├── cast_op.cu
│   │   ├── cast_op.h
│   │   ├── ceil_op.cc
│   │   ├── ceil_op.cu
│   │   ├── ceil_op.h
│   │   ├── channel_backprop_stats_op.cc
│   │   ├── channel_backprop_stats_op.h
│   │   ├── channel_shuffle_op.cc
│   │   ├── channel_shuffle_op.h
│   │   ├── channel_shuffle_op_gpu.cu
│   │   ├── channel_stats_op.cc
│   │   ├── channel_stats_op.cu
│   │   ├── channel_stats_op.h
│   │   ├── clip_op.cc
│   │   ├── clip_op.cu
│   │   ├── clip_op.h
│   │   ├── communicator_op.cc
│   │   ├── communicator_op_gpu.cc
│   │   ├── concat_split_op.cc
│   │   ├── concat_split_op.h
│   │   ├── concat_split_op_gpu.cc
│   │   ├── conditional_op.cc
│   │   ├── conditional_op.h
│   │   ├── conv_gradient_op.cc
│   │   ├── conv_op.cc
│   │   ├── conv_op.h
│   │   ├── conv_op_cache_cudnn.cc
│   │   ├── conv_op_cache_cudnn.h
│   │   ├── conv_op_cache_cudnn_test.cc
│   │   ├── conv_op_cudnn.cc
│   │   ├── conv_op_eigen.cc
│   │   ├── conv_op_gpu.cc
│   │   ├── conv_op_impl.h
│   │   ├── conv_op_shared.cc
│   │   ├── conv_op_shared.h
│   │   ├── conv_op_shared_gpu.cc
│   │   ├── conv_pool_op_base.h
│   │   ├── conv_transpose_gradient_op.cc
│   │   ├── conv_transpose_op.cc
│   │   ├── conv_transpose_op.h
│   │   ├── conv_transpose_op_cudnn.cc
│   │   ├── conv_transpose_op_gpu.cc
│   │   ├── conv_transpose_op_impl.h
│   │   ├── conv_transpose_op_mobile.cc
│   │   ├── conv_transpose_op_mobile.h
│   │   ├── conv_transpose_op_mobile_impl.h
│   │   ├── conv_transpose_op_mobile_test.cc
│   │   ├── conv_transpose_unpool_op_base.h
│   │   ├── cos_op.cc
│   │   ├── cos_op.cu
│   │   ├── cosine_embedding_criterion_op.cc
│   │   ├── cosine_embedding_criterion_op.cu
│   │   ├── cosine_embedding_criterion_op.h
│   │   ├── counter_ops.cc
│   │   ├── counter_ops.h
│   │   ├── counter_ops_gpu.cc
│   │   ├── create_scope_op.cc
│   │   ├── create_scope_op.h
│   │   ├── cross_entropy_op.cc
│   │   ├── cross_entropy_op.cu
│   │   ├── cross_entropy_op.h
│   │   ├── dataset_ops.cc
│   │   ├── dataset_ops.h
│   │   ├── deform_conv_gradient_op.cc
│   │   ├── deform_conv_op.cc
│   │   ├── deform_conv_op.cu
│   │   ├── deform_conv_op.h
│   │   ├── deform_conv_op_impl.h
│   │   ├── distance_op.cc
│   │   ├── distance_op.cu
│   │   ├── distance_op.h
│   │   ├── do_op.cc
│   │   ├── do_op.h
│   │   ├── do_op_gpu.cc
│   │   ├── dropout_op.cc
│   │   ├── dropout_op.cu
│   │   ├── dropout_op.h
│   │   ├── dropout_op_cudnn.cc
│   │   ├── elementwise_add_op.cc
│   │   ├── elementwise_div_op.cc
│   │   ├── elementwise_linear_op.cc
│   │   ├── elementwise_linear_op.cu
│   │   ├── elementwise_linear_op.h
│   │   ├── elementwise_logical_ops.cc
│   │   ├── elementwise_logical_ops.h
│   │   ├── elementwise_mul_op.cc
│   │   ├── elementwise_op.cc
│   │   ├── elementwise_op.cu
│   │   ├── elementwise_op.h
│   │   ├── elementwise_op_gpu_test.cc
│   │   ├── elementwise_op_schema.cc
│   │   ├── elementwise_op_test.cc
│   │   ├── elementwise_op_test.h
│   │   ├── elementwise_sub_op.cc
│   │   ├── elementwise_sum_op.cc
│   │   ├── elu_op.cc
│   │   ├── elu_op.cu
│   │   ├── elu_op.h
│   │   ├── exp_op.cc
│   │   ├── exp_op.cu
│   │   ├── expand_squeeze_dims_op.cc
│   │   ├── expand_squeeze_dims_op.h
│   │   ├── expand_squeeze_dims_op_gpu.cc
│   │   ├── extend_tensor_op.cc
│   │   ├── feed_blob_op.cc
│   │   ├── feed_blob_op.h
│   │   ├── filler_op.cc
│   │   ├── filler_op.cu
│   │   ├── filler_op.h
│   │   ├── filler_op_gpu.cc
│   │   ├── find_duplicate_elements_op.cc
│   │   ├── find_duplicate_elements_op.h
│   │   ├── find_op.cc
│   │   ├── find_op.cu
│   │   ├── find_op.h
│   │   ├── flatten_op.cc
│   │   ├── flatten_op.h
│   │   ├── flexible_top_k.cc
│   │   ├── flexible_top_k.h
│   │   ├── floor_op.cc
│   │   ├── floor_op.cu
│   │   ├── floor_op.h
│   │   ├── free_op.cc
│   │   ├── free_op.h
│   │   ├── free_op_gpu.cc
│   │   ├── fully_connected_op.cc
│   │   ├── fully_connected_op.h
│   │   ├── fully_connected_op_gpu.cc
│   │   ├── fused_rowwise_8bit_conversion_ops.cc
│   │   ├── fused_rowwise_8bit_conversion_ops.h
│   │   ├── gather_fused_8bit_rowwise_op.cc
│   │   ├── gather_fused_8bit_rowwise_op.h
│   │   ├── gather_ranges_to_dense_op.cc
│   │   ├── gather_ranges_to_dense_op.h
│   │   ├── generate_proposals_op.cc
│   │   ├── generate_proposals_op.h
│   │   ├── generate_proposals_op_test.cc
│   │   ├── generate_proposals_op_util_boxes.h
│   │   ├── generate_proposals_op_util_boxes_test.cc
│   │   ├── generate_proposals_op_util_nms.h
│   │   ├── generate_proposals_op_util_nms_test.cc
│   │   ├── given_tensor_fill_op.cc
│   │   ├── given_tensor_fill_op.cu
│   │   ├── given_tensor_fill_op.h
│   │   ├── glu_op.cc
│   │   ├── glu_op.cu
│   │   ├── glu_op.h
│   │   ├── gru_unit_op.cc
│   │   ├── gru_unit_op.h
│   │   ├── gru_unit_op_gpu.cu
│   │   ├── h_softmax_op.cc
│   │   ├── h_softmax_op.h
│   │   ├── half_float_ops.cc
│   │   ├── half_float_ops.cu
│   │   ├── half_float_ops.h
│   │   ├── if_op.cc
│   │   ├── if_op.h
│   │   ├── if_op_gpu.cc
│   │   ├── im2col_op.cc
│   │   ├── im2col_op.h
│   │   ├── im2col_op_gpu.cc
│   │   ├── index_hash_ops.cc
│   │   ├── index_hash_ops.h
│   │   ├── index_ops.cc
│   │   ├── instance_norm_gradient_op.cc
│   │   ├── instance_norm_op.cc
│   │   ├── instance_norm_op.cu
│   │   ├── instance_norm_op.h
│   │   ├── jsd_op.cc
│   │   ├── jsd_op.h
│   │   ├── key_split_ops.cc
│   │   ├── key_split_ops.h
│   │   ├── last_n_window_collector.cc
│   │   ├── layer_norm_op.cc
│   │   ├── layer_norm_op.cu
│   │   ├── layer_norm_op.h
│   │   ├── leaky_relu_op.cc
│   │   ├── leaky_relu_op.cu
│   │   ├── leaky_relu_op.h
│   │   ├── lengths_reducer_fused_8bit_rowwise_ops.cc
│   │   ├── lengths_reducer_fused_8bit_rowwise_ops.h
│   │   ├── lengths_reducer_ops.cc
│   │   ├── lengths_reducer_ops.h
│   │   ├── lengths_reducer_rowwise_8bit_ops.cc
│   │   ├── lengths_reducer_rowwise_8bit_ops.h
│   │   ├── lengths_tile_op.cc
│   │   ├── lengths_tile_op.h
│   │   ├── lengths_tile_op_gpu.cc
│   │   ├── lengths_top_k_op.cc
│   │   ├── lengths_top_k_op.h
│   │   ├── listwise_l2r_op.cc
│   │   ├── listwise_l2r_op.h
│   │   ├── load_save_op.cc
│   │   ├── load_save_op.h
│   │   ├── load_save_op_gpu.cc
│   │   ├── local_response_normalization_op.cc
│   │   ├── local_response_normalization_op.cu
│   │   ├── local_response_normalization_op.h
│   │   ├── local_response_normalization_op_cudnn.cc
│   │   ├── locally_connected_op.cc
│   │   ├── locally_connected_op.h
│   │   ├── locally_connected_op_gpu.cc
│   │   ├── locally_connected_op_impl.h
│   │   ├── locally_connected_op_util.cc
│   │   ├── locally_connected_op_util.h
│   │   ├── log_op.cc
│   │   ├── log_op.cu
│   │   ├── logit_op.cc
│   │   ├── logit_op.cu
│   │   ├── logit_op.h
│   │   ├── loss_op.cc
│   │   ├── loss_op.cu
│   │   ├── loss_op.h
│   │   ├── lp_pool_op.cc
│   │   ├── lp_pool_op.cu
│   │   ├── lpnorm_op.cc
│   │   ├── lpnorm_op.h
│   │   ├── lstm_unit_op.cc
│   │   ├── lstm_unit_op.h
│   │   ├── lstm_unit_op_gpu.cu
│   │   ├── map_ops.cc
│   │   ├── map_ops.h
│   │   ├── margin_ranking_criterion_op.cc
│   │   ├── margin_ranking_criterion_op.cu
│   │   ├── margin_ranking_criterion_op.h
│   │   ├── math_ops.cc
│   │   ├── math_ops.cu
│   │   ├── math_ops.h
│   │   ├── matmul_op.cc
│   │   ├── matmul_op.h
│   │   ├── matmul_op_gpu.cc
│   │   ├── max_pool_with_index.cu
│   │   ├── max_pool_with_index.h
│   │   ├── mean_op.cc
│   │   ├── mean_op.cu
│   │   ├── mean_op.h
│   │   ├── mem_query_op.cu
│   │   ├── merge_id_lists_op.cc
│   │   ├── merge_id_lists_op.h
│   │   ├── minmax_gradient_ops.cc
│   │   ├── minmax_ops.cc
│   │   ├── minmax_ops.h
│   │   ├── mod_op.cc
│   │   ├── mod_op.h
│   │   ├── multi_class_accuracy_op.cc
│   │   ├── multi_class_accuracy_op.cu
│   │   ├── multi_class_accuracy_op.h
│   │   ├── negate_gradient_op.cc
│   │   ├── negate_gradient_op.h
│   │   ├── negate_gradient_op_gpu.cc
│   │   ├── negative_op.cc
│   │   ├── negative_op.cu
│   │   ├── ngram_ops.cc
│   │   ├── ngram_ops.h
│   │   ├── no_default_engine_op.h
│   │   ├── norm_planar_yuv_op.cc
│   │   ├── normalize_l1_op.cc
│   │   ├── normalize_l1_op.h
│   │   ├── normalize_op.cc
│   │   ├── normalize_op.h
│   │   ├── normalize_ops.cu
│   │   ├── one_hot_ops.cc
│   │   ├── one_hot_ops.cu
│   │   ├── one_hot_ops.h
│   │   ├── onnx_while_op.cc
│   │   ├── onnx_while_op.h
│   │   ├── op_utils_cudnn.h
│   │   ├── operator_fallback_gpu.h
│   │   ├── operator_fallback_gpu_test.cc
│   │   ├── order_switch_ops.cc
│   │   ├── order_switch_ops.cu
│   │   ├── order_switch_ops.h
│   │   ├── pack_rnn_sequence_op.cc
│   │   ├── pack_rnn_sequence_op.h
│   │   ├── pack_segments.cc
│   │   ├── pack_segments.cu
│   │   ├── pack_segments.h
│   │   ├── pad_op.cc
│   │   ├── pad_op.h
│   │   ├── pad_op_gpu.cu
│   │   ├── partition_ops.cc
│   │   ├── partition_ops.h
│   │   ├── percentile_op.cc
│   │   ├── percentile_op.h
│   │   ├── perplexity_op.cc
│   │   ├── perplexity_op.cu
│   │   ├── perplexity_op.h
│   │   ├── piecewise_linear_transform_op.cc
│   │   ├── piecewise_linear_transform_op.cu
│   │   ├── piecewise_linear_transform_op.h
│   │   ├── pool_gradient_op.cc
│   │   ├── pool_op.cc
│   │   ├── pool_op.cu
│   │   ├── pool_op.h
│   │   ├── pool_op_cudnn.cu
│   │   ├── pow_op.cc
│   │   ├── pow_op.cu
│   │   ├── pow_op.h
│   │   ├── prefetch_op.h
│   │   ├── prelu_op.cc
│   │   ├── prelu_op.cu
│   │   ├── prelu_op.h
│   │   ├── prepend_dim_op.cc
│   │   ├── prepend_dim_op.h
│   │   ├── prepend_dim_op_gpu.cc
│   │   ├── quant_decode_op.cc
│   │   ├── quant_decode_op.h
│   │   ├── rank_loss_op.cc
│   │   ├── rank_loss_op.h
│   │   ├── recurrent_network_blob_fetcher_op.cc
│   │   ├── recurrent_network_blob_fetcher_op.h
│   │   ├── recurrent_network_blob_fetcher_op_gpu.cc
│   │   ├── recurrent_network_executor.cc
│   │   ├── recurrent_network_executor.h
│   │   ├── recurrent_network_executor_gpu.cc
│   │   ├── recurrent_network_executor_gpu.h
│   │   ├── recurrent_network_executor_incl.h
│   │   ├── recurrent_network_op.cc
│   │   ├── recurrent_network_op.h
│   │   ├── recurrent_network_op_gpu.cu
│   │   ├── recurrent_op_cudnn.cc
│   │   ├── recurrent_op_cudnn.h
│   │   ├── reduce_ops.cc
│   │   ├── reduce_ops.h
│   │   ├── reducer_functors.h
│   │   ├── reduction_front_back_ops.cc
│   │   ├── reduction_front_back_ops.cu
│   │   ├── reduction_front_back_ops.h
│   │   ├── reduction_ops.cc
│   │   ├── reduction_ops.cu
│   │   ├── reduction_ops.h
│   │   ├── relu_op.cc
│   │   ├── relu_op.cu
│   │   ├── relu_op.h
│   │   ├── relu_op_cudnn.cc
│   │   ├── relu_op_fp16.cu
│   │   ├── remove_data_blocks_op.cc
│   │   ├── remove_data_blocks_op.h
│   │   ├── replace_nan_op.cc
│   │   ├── replace_nan_op.cu
│   │   ├── replace_nan_op.h
│   │   ├── reservoir_sampling.cc
│   │   ├── reshape_op.cc
│   │   ├── reshape_op.h
│   │   ├── reshape_op_gpu.cc
│   │   ├── reshape_op_gpu_test.cc
│   │   ├── resize_op.cc
│   │   ├── resize_op.cu
│   │   ├── resize_op.h
│   │   ├── reverse_packed_segs_op.cc
│   │   ├── reverse_packed_segs_op.cu
│   │   ├── reverse_packed_segs_op.h
│   │   ├── rmac_regions_op.cc
│   │   ├── rmac_regions_op.cu
│   │   ├── rmac_regions_op.h
│   │   ├── roi_align_gradient_op.cc
│   │   ├── roi_align_gradient_op.cu
│   │   ├── roi_align_gradient_op.h
│   │   ├── roi_align_op.cc
│   │   ├── roi_align_op.cu
│   │   ├── roi_align_op.h
│   │   ├── roi_align_op_gpu_test.cc
│   │   ├── roi_pool_op.cc
│   │   ├── roi_pool_op.cu
│   │   ├── roi_pool_op.h
│   │   ├── rowmul_op.cc
│   │   ├── rowmul_op.h
│   │   ├── scale_op.cc
│   │   ├── scale_op.h
│   │   ├── scale_op_gpu.cc
│   │   ├── segment_reduction_op.cc
│   │   ├── segment_reduction_op.h
│   │   ├── segment_reduction_op_gpu.cu
│   │   ├── selu_op.cc
│   │   ├── selu_op.cu
│   │   ├── selu_op.h
│   │   ├── sequence_ops.cc
│   │   ├── sequence_ops.cu
│   │   ├── sequence_ops.h
│   │   ├── shape_op.cc
│   │   ├── shape_op.h
│   │   ├── shape_op_gpu.cc
│   │   ├── sigmoid_op.cc
│   │   ├── sigmoid_op.cu
│   │   ├── sin_op.cc
│   │   ├── sin_op.cu
│   │   ├── sinusoid_position_encoding_op.cc
│   │   ├── sinusoid_position_encoding_op.h
│   │   ├── slice_op.cc
│   │   ├── slice_op.cu
│   │   ├── slice_op.h
│   │   ├── softmax_op.cc
│   │   ├── softmax_op.h
│   │   ├── softmax_op_cudnn.cc
│   │   ├── softmax_ops.cu
│   │   ├── softmax_shared.cc
│   │   ├── softmax_shared.h
│   │   ├── softmax_with_loss_op.cc
│   │   ├── softmax_with_loss_op.h
│   │   ├── softplus_op.cc
│   │   ├── softplus_op.cu
│   │   ├── softplus_op.h
│   │   ├── softsign_op.cc
│   │   ├── softsign_op.cu
│   │   ├── space_batch_op.cc
│   │   ├── space_batch_op.h
│   │   ├── space_batch_op_gpu.cu
│   │   ├── sparse_normalize_op.cc
│   │   ├── sparse_normalize_op.h
│   │   ├── sparse_to_dense_mask_op.cc
│   │   ├── sparse_to_dense_mask_op.h
│   │   ├── sparse_to_dense_op.cc
│   │   ├── sparse_to_dense_op.cu
│   │   ├── sparse_to_dense_op.h
│   │   ├── spatial_batch_norm_gradient_op.cc
│   │   ├── spatial_batch_norm_op.cc
│   │   ├── spatial_batch_norm_op.h
│   │   ├── spatial_batch_norm_op_cudnn.cc
│   │   ├── spatial_softmax_with_loss_op.cc
│   │   ├── spatial_softmax_with_loss_op.h
│   │   ├── sqrt_op.cc
│   │   ├── sqrt_op.cu
│   │   ├── square_root_divide_op.cc
│   │   ├── square_root_divide_op.h
│   │   ├── stats_ops.cc
│   │   ├── stop_gradient.cc
│   │   ├── stop_gradient.h
│   │   ├── stop_gradient_gpu.cc
│   │   ├── string_ops.cc
│   │   ├── string_ops.h
│   │   ├── string_ops_test.cc
│   │   ├── stylizer_ops.cc
│   │   ├── summarize_op.cc
│   │   ├── summarize_op.cu
│   │   ├── summarize_op.h
│   │   ├── swish_op.cc
│   │   ├── swish_op.cu
│   │   ├── swish_op.h
│   │   ├── tanh_op.cc
│   │   ├── tanh_op.cu
│   │   ├── tensor_protos_db_input.cc
│   │   ├── tensor_protos_db_input.h
│   │   ├── tensor_protos_db_input_gpu.cc
│   │   ├── text_file_reader.cc
│   │   ├── text_file_reader_utils.cc
│   │   ├── text_file_reader_utils.h
│   │   ├── text_file_reader_utils_test.cc
│   │   ├── thresholded_relu_op.cc
│   │   ├── thresholded_relu_op.cu
│   │   ├── thresholded_relu_op.h
│   │   ├── tile_op.cc
│   │   ├── tile_op.cu
│   │   ├── tile_op.h
│   │   ├── top_k.cc
│   │   ├── top_k.cu
│   │   ├── top_k.h
│   │   ├── top_k_heap_selection.cuh
│   │   ├── top_k_radix_selection.cuh
│   │   ├── transpose_op.cc
│   │   ├── transpose_op.cu
│   │   ├── transpose_op.h
│   │   ├── transpose_op_cudnn.cc
│   │   ├── tt_linear_op.cc
│   │   ├── tt_linear_op.h
│   │   ├── utility_ops.cc
│   │   ├── utility_ops.cu
│   │   ├── utility_ops.h
│   │   ├── utility_ops_gpu.cc
│   │   ├── utility_ops_gpu_test.cc
│   │   ├── utility_ops_test.cc
│   │   ├── variable_length_sequence_padding.cc
│   │   ├── variable_length_sequence_padding.h
│   │   ├── weighted_sample_op.cc
│   │   ├── weighted_sample_op.cu
│   │   ├── weighted_sample_op.h
│   │   ├── while_op.cc
│   │   ├── while_op.h
│   │   ├── while_op_gpu.cc
│   │   ├── workspace_ops.cc
│   │   ├── zero_gradient_op.cc
│   │   ├── zero_gradient_op.h
│   │   └── zero_gradient_op_gpu.cc
│   ├── perfkernels/
│   │   ├── CMakeLists.txt
│   │   ├── common.h
│   │   ├── common_avx.cc
│   │   ├── common_avx2.cc
│   │   ├── cvtsh_ss_bugfix.h
│   │   ├── embedding_lookup.cc
│   │   ├── embedding_lookup.h
│   │   ├── embedding_lookup_avx2.cc
│   │   ├── embedding_lookup_fused_8bit_rowwise_avx2.cc
│   │   ├── fused_8bit_rowwise_embedding_lookup.cc
│   │   ├── fused_8bit_rowwise_embedding_lookup.h
│   │   ├── hp_emblookup_codegen.py
│   │   ├── typed_axpy.cc
│   │   ├── typed_axpy.h
│   │   ├── typed_axpy_avx.cc
│   │   └── typed_axpy_avx2.cc
│   ├── proto/
│   │   ├── CMakeLists.txt
│   │   ├── __init__.py
│   │   ├── caffe2.proto
│   │   ├── caffe2_legacy.proto
│   │   ├── hsm.proto
│   │   ├── metanet.proto
│   │   ├── predictor_consts.proto
│   │   └── prof_dag.proto
│   ├── python/
│   │   ├── CMakeLists.txt
│   │   ├── __init__.py
│   │   ├── _import_c_extension.py
│   │   ├── allcompare_test.py
│   │   ├── attention.py
│   │   ├── benchmark_generator.py
│   │   ├── binarysize.py
│   │   ├── brew.py
│   │   ├── brew_test.py
│   │   ├── build.py
│   │   ├── cached_reader.py
│   │   ├── caffe_translator.py
│   │   ├── caffe_translator_test.py
│   │   ├── checkpoint.py
│   │   ├── checkpoint_test.py
│   │   ├── cnn.py
│   │   ├── context.py
│   │   ├── context_test.py
│   │   ├── control.py
│   │   ├── control_ops_grad.py
│   │   ├── control_ops_util.py
│   │   ├── control_test.py
│   │   ├── convnet_benchmarks.py
│   │   ├── convnet_benchmarks_test.py
│   │   ├── core.py
│   │   ├── core_gradients_test.py
│   │   ├── core_test.py
│   │   ├── crf.py
│   │   ├── data_parallel_model.py
│   │   ├── data_parallel_model_test.py
│   │   ├── data_parallel_model_utils.py
│   │   ├── data_workers.py
│   │   ├── data_workers_test.py
│   │   ├── dataio.py
│   │   ├── dataio_test.py
│   │   ├── dataset.py
│   │   ├── db_test.py
│   │   ├── device_checker.py
│   │   ├── dlpack.h
│   │   ├── docs/
│   │   │   ├── formatter.py
│   │   │   ├── generator.py
│   │   │   ├── github.py
│   │   │   └── parser.py
│   │   ├── dyndep.py
│   │   ├── embedding_generation_benchmark.py
│   │   ├── examples/
│   │   │   ├── char_rnn.py
│   │   │   ├── lmdb_create_example.py
│   │   │   └── resnet50_trainer.py
│   │   ├── experiment_util.py
│   │   ├── extension_loader.py
│   │   ├── functional.py
│   │   ├── functional_test.py
│   │   ├── fused_8bit_rowwise_conversion_ops_test.py
│   │   ├── gradient_check_test.py
│   │   ├── gradient_checker.py
│   │   ├── gru_cell.py
│   │   ├── helpers/
│   │   │   ├── __init__.py
│   │   │   ├── algebra.py
│   │   │   ├── arg_scope.py
│   │   │   ├── array_helpers.py
│   │   │   ├── control_ops.py
│   │   │   ├── conv.py
│   │   │   ├── db_input.py
│   │   │   ├── dropout.py
│   │   │   ├── elementwise_linear.py
│   │   │   ├── fc.py
│   │   │   ├── nonlinearity.py
│   │   │   ├── normalization.py
│   │   │   ├── pooling.py
│   │   │   ├── tools.py
│   │   │   └── train.py
│   │   ├── hsm_util.py
│   │   ├── hypothesis_test.py
│   │   ├── hypothesis_test_util.py
│   │   ├── layer_model_helper.py
│   │   ├── layer_model_instantiator.py
│   │   ├── layer_parameter_sharing_test.py
│   │   ├── layer_test_util.py
│   │   ├── layers/
│   │   │   ├── __init__.py
│   │   │   ├── add_bias.py
│   │   │   ├── arc_cosine_feature_map.py
│   │   │   ├── batch_distill_lr_loss.py
│   │   │   ├── batch_lr_loss.py
│   │   │   ├── batch_mse_loss.py
│   │   │   ├── batch_normalization.py
│   │   │   ├── batch_sigmoid_cross_entropy_loss.py
│   │   │   ├── batch_softmax_loss.py
│   │   │   ├── concat.py
│   │   │   ├── conv.py
│   │   │   ├── dropout.py
│   │   │   ├── fc.py
│   │   │   ├── fc_without_bias.py
│   │   │   ├── feature_sparse_to_dense.py
│   │   │   ├── functional.py
│   │   │   ├── gather_record.py
│   │   │   ├── last_n_window_collector.py
│   │   │   ├── layers.py
│   │   │   ├── margin_rank_loss.py
│   │   │   ├── merge_id_lists.py
│   │   │   ├── pairwise_dot_product.py
│   │   │   ├── position_weighted.py
│   │   │   ├── random_fourier_features.py
│   │   │   ├── reservoir_sampling.py
│   │   │   ├── sampling_train.py
│   │   │   ├── sampling_trainable_mixin.py
│   │   │   ├── select_record_by_context.py
│   │   │   ├── semi_random_features.py
│   │   │   ├── sparse_feature_hash.py
│   │   │   ├── sparse_lookup.py
│   │   │   ├── split.py
│   │   │   ├── tags.py
│   │   │   └── uniform_sampling.py
│   │   ├── layers_test.py
│   │   ├── lengths_reducer_fused_8bit_rowwise_ops_test.py
│   │   ├── lengths_reducer_rowwise_8bit_ops_test.py
│   │   ├── lstm_benchmark.py
│   │   ├── memonger.py
│   │   ├── memonger_test.py
│   │   ├── mint/
│   │   │   ├── app.py
│   │   │   ├── static/
│   │   │   │   └── css/
│   │   │   │       └── simple-sidebar.css
│   │   │   └── templates/
│   │   │       └── index.html
│   │   ├── mkl/
│   │   │   ├── convnet_benchmarks.py
│   │   │   ├── mkl_LRN_op_test.py
│   │   │   ├── mkl_LRN_speed_test.py
│   │   │   ├── mkl_concat_op_test.py
│   │   │   ├── mkl_conv_op_test.py
│   │   │   ├── mkl_copy_op_test.py
│   │   │   ├── mkl_elementwise_add_op_test.py
│   │   │   ├── mkl_elementwise_sum_op_test.py
│   │   │   ├── mkl_fc_op_test.py
│   │   │   ├── mkl_fc_speed_test.py
│   │   │   ├── mkl_fill_op_test.py
│   │   │   ├── mkl_pool_op_test.py
│   │   │   ├── mkl_pool_speed_test.py
│   │   │   ├── mkl_relu_op_test.py
│   │   │   ├── mkl_sbn_op_test.py
│   │   │   ├── mkl_sbn_speed_test.py
│   │   │   ├── mkl_sigmoid_op_test.py
│   │   │   ├── mkl_speed_test.py
│   │   │   ├── mkl_squeeze_op_test.py
│   │   │   ├── rewrite_graph.py
│   │   │   └── rewrite_graph_test.py
│   │   ├── mkl_test_util.py
│   │   ├── model_device_test.py
│   │   ├── model_helper.py
│   │   ├── modeling/
│   │   │   ├── __init__.py
│   │   │   ├── compute_norm_for_blobs.py
│   │   │   ├── compute_norm_for_blobs_test.py
│   │   │   ├── compute_statistics_for_blobs.py
│   │   │   ├── compute_statistics_for_blobs_test.py
│   │   │   ├── initializers.py
│   │   │   ├── initializers_test.py
│   │   │   ├── net_modifier.py
│   │   │   ├── parameter_info.py
│   │   │   ├── parameter_sharing.py
│   │   │   └── parameter_sharing_test.py
│   │   ├── models/
│   │   │   ├── __init__.py
│   │   │   ├── __sym_init__.py
│   │   │   ├── download.py
│   │   │   ├── resnet.py
│   │   │   ├── resnet_test.py
│   │   │   └── seq2seq/
│   │   │       ├── __init__.py
│   │   │       ├── beam_search.py
│   │   │       ├── seq2seq_beam_search_test.py
│   │   │       ├── seq2seq_model_helper.py
│   │   │       ├── seq2seq_model_helper_test.py
│   │   │       ├── seq2seq_util.py
│   │   │       ├── train.py
│   │   │       └── translate.py
│   │   ├── modifier_context.py
│   │   ├── mpi_python.cc
│   │   ├── muji.py
│   │   ├── muji_test.py
│   │   ├── net_builder.py
│   │   ├── net_builder_test.py
│   │   ├── net_drawer.py
│   │   ├── net_printer.py
│   │   ├── net_printer_test.py
│   │   ├── numa_benchmark.py
│   │   ├── numa_test.py
│   │   ├── observer_test.py
│   │   ├── onnx/
│   │   │   ├── ONNXOpCoverage.md
│   │   │   ├── README.md
│   │   │   ├── __init__.py
│   │   │   ├── backend.py
│   │   │   ├── backend_cpp_rep.py
│   │   │   ├── backend_rep.py
│   │   │   ├── bin/
│   │   │   │   ├── __init__.py
│   │   │   │   └── conversion.py
│   │   │   ├── error.py
│   │   │   ├── frontend.py
│   │   │   ├── helper.py
│   │   │   ├── tests/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── c2_ref_test.py
│   │   │   │   ├── conversion_test.py
│   │   │   │   ├── helper_test.py
│   │   │   │   ├── onnx_backend_test.py
│   │   │   │   ├── optimize_onnx_test.py
│   │   │   │   ├── ssa_test.py
│   │   │   │   └── test_utils.py
│   │   │   └── workspace.py
│   │   ├── operator_test/
│   │   │   ├── activation_ops_test.py
│   │   │   ├── adagrad_test.py
│   │   │   ├── adam_test.py
│   │   │   ├── apmeter_test.py
│   │   │   ├── assert_test.py
│   │   │   ├── atomic_ops_test.py
│   │   │   ├── basic_rnn_test.py
│   │   │   ├── batch_box_cox_test.py
│   │   │   ├── batch_sparse_to_dense_op_test.py
│   │   │   ├── bbox_transform_test.py
│   │   │   ├── blobs_queue_db_test.py
│   │   │   ├── boolean_mask_test.py
│   │   │   ├── boolean_unmask_test.py
│   │   │   ├── cast_op_test.py
│   │   │   ├── ceil_op_test.py
│   │   │   ├── channel_backprop_stats_op_test.py
│   │   │   ├── channel_shuffle_test.py
│   │   │   ├── channel_stats_op_test.py
│   │   │   ├── checkpoint_test.py
│   │   │   ├── clip_op_test.py
│   │   │   ├── clip_tensor_op_test.py
│   │   │   ├── concat_split_op_test.py
│   │   │   ├── conditional_test.py
│   │   │   ├── conv_test.py
│   │   │   ├── conv_transpose_test.py
│   │   │   ├── copy_ops_test.py
│   │   │   ├── cosine_embedding_criterion_op_test.py
│   │   │   ├── counter_ops_test.py
│   │   │   ├── crf_test.py
│   │   │   ├── cross_entropy_ops_test.py
│   │   │   ├── cudnn_recurrent_test.py
│   │   │   ├── dataset_ops_test.py
│   │   │   ├── deform_conv_test.py
│   │   │   ├── distance_op_test.py
│   │   │   ├── dropout_op_test.py
│   │   │   ├── duplicate_operands_test.py
│   │   │   ├── elementwise_linear_op_test.py
│   │   │   ├── elementwise_logical_ops_test.py
│   │   │   ├── elementwise_op_broadcast_test.py
│   │   │   ├── elementwise_ops_test.py
│   │   │   ├── emptysample_ops_test.py
│   │   │   ├── extend_tensor_op_test.py
│   │   │   ├── fc_operator_test.py
│   │   │   ├── filler_ops_test.py
│   │   │   ├── find_op_test.py
│   │   │   ├── flatten_op_test.py
│   │   │   ├── flexible_top_k_test.py
│   │   │   ├── floor_op_test.py
│   │   │   ├── gather_ops_test.py
│   │   │   ├── gather_ranges_op_test.py
│   │   │   ├── given_tensor_fill_op_test.py
│   │   │   ├── glu_op_test.py
│   │   │   ├── group_conv_test.py
│   │   │   ├── gru_test.py
│   │   │   ├── hsm_test.py
│   │   │   ├── im2col_col2im_test.py
│   │   │   ├── image_input_op_test.py
│   │   │   ├── index_hash_ops_test.py
│   │   │   ├── index_ops_test.py
│   │   │   ├── instance_norm_test.py
│   │   │   ├── jsd_ops_test.py
│   │   │   ├── key_split_ops_test.py
│   │   │   ├── lars_test.py
│   │   │   ├── layer_norm_op_test.py
│   │   │   ├── lc_operator_test.py
│   │   │   ├── leaky_relu_test.py
│   │   │   ├── learning_rate_op_test.py
│   │   │   ├── lengths_tile_op_test.py
│   │   │   ├── lengths_top_k_ops_test.py
│   │   │   ├── listwise_l2r_operator_test.py
│   │   │   ├── load_save_test.py
│   │   │   ├── loss_ops_test.py
│   │   │   ├── lpnorm_op_test.py
│   │   │   ├── map_ops_test.py
│   │   │   ├── margin_ranking_criterion_op_test.py
│   │   │   ├── math_ops_test.py
│   │   │   ├── matmul_op_test.py
│   │   │   ├── mean_op_test.py
│   │   │   ├── merge_id_lists_op_test.py
│   │   │   ├── mkl_conv_op_test.py
│   │   │   ├── mkl_packed_fc_op_test.py
│   │   │   ├── mkl_speed_test.py
│   │   │   ├── mod_op_test.py
│   │   │   ├── momentum_sgd_test.py
│   │   │   ├── mpi_test.py
│   │   │   ├── negate_gradient_op_test.py
│   │   │   ├── ngram_ops_test.py
│   │   │   ├── normalize_op_test.py
│   │   │   ├── one_hot_ops_test.py
│   │   │   ├── onnx_while_test.py
│   │   │   ├── pack_ops_test.py
│   │   │   ├── pack_rnn_sequence_op_test.py
│   │   │   ├── pad_test.py
│   │   │   ├── partition_ops_test.py
│   │   │   ├── percentile_op_test.py
│   │   │   ├── piecewise_linear_transform_test.py
│   │   │   ├── pooling_test.py
│   │   │   ├── prepend_dim_test.py
│   │   │   ├── python_op_test.py
│   │   │   ├── rank_loss_operator_test.py
│   │   │   ├── rebatching_queue_test.py
│   │   │   ├── record_queue_test.py
│   │   │   ├── recurrent_net_executor_test.py
│   │   │   ├── recurrent_network_test.py
│   │   │   ├── reduce_ops_test.py
│   │   │   ├── reduction_ops_test.py
│   │   │   ├── relu_op_test.py
│   │   │   ├── reshape_ops_test.py
│   │   │   ├── resize_op_test.py
│   │   │   ├── rmac_regions_op_test.py
│   │   │   ├── rnn_cell_test.py
│   │   │   ├── segment_ops_test.py
│   │   │   ├── selu_op_test.py
│   │   │   ├── sequence_ops_test.py
│   │   │   ├── shape_inference_test.py
│   │   │   ├── sinusoid_position_encoding_op_test.py
│   │   │   ├── softmax_ops_test.py
│   │   │   ├── softplus_op_test.py
│   │   │   ├── sparse_gradient_checker_test.py
│   │   │   ├── sparse_lengths_sum_benchmark.py
│   │   │   ├── sparse_normalize_test.py
│   │   │   ├── sparse_ops_test.py
│   │   │   ├── sparse_to_dense_mask_op_test.py
│   │   │   ├── spatial_bn_op_test.py
│   │   │   ├── specialized_segment_ops_test.py
│   │   │   ├── square_root_divide_op_test.py
│   │   │   ├── stats_ops_test.py
│   │   │   ├── string_ops_test.py
│   │   │   ├── text_file_reader_test.py
│   │   │   ├── thresholded_relu_op_test.py
│   │   │   ├── tile_op_test.py
│   │   │   ├── top_k_test.py
│   │   │   ├── unique_uniform_fill_op_test.py
│   │   │   ├── utility_ops_test.py
│   │   │   ├── video_input_op_test.py
│   │   │   ├── weighted_sample_test.py
│   │   │   └── weighted_sum_test.py
│   │   ├── optimizer.py
│   │   ├── optimizer_context.py
│   │   ├── optimizer_test.py
│   │   ├── optimizer_test_util.py
│   │   ├── parallel_workers.py
│   │   ├── parallel_workers_test.py
│   │   ├── parallelize_bmuf_distributed_test.py
│   │   ├── pipeline.py
│   │   ├── pipeline_test.py
│   │   ├── predictor/
│   │   │   ├── __init__.py
│   │   │   ├── mobile_exporter.py
│   │   │   ├── mobile_exporter_test.py
│   │   │   ├── predictor_exporter.py
│   │   │   ├── predictor_exporter_test.py
│   │   │   ├── predictor_py_utils.py
│   │   │   ├── predictor_test.py
│   │   │   └── serde.py
│   │   ├── predictor_constants.py
│   │   ├── pybind_state.cc
│   │   ├── pybind_state.h
│   │   ├── pybind_state_dlpack.cc
│   │   ├── pybind_state_dlpack.h
│   │   ├── pybind_state_gpu.cc
│   │   ├── pybind_state_mkl.cc
│   │   ├── python_op_test.py
│   │   ├── queue_util.py
│   │   ├── record_queue.py
│   │   ├── recurrent.py
│   │   ├── regularizer.py
│   │   ├── regularizer_context.py
│   │   ├── regularizer_test.py
│   │   ├── rnn/
│   │   │   ├── lstm_comparison.py
│   │   │   └── rnn_cell_test_util.py
│   │   ├── rnn_cell.py
│   │   ├── schema.py
│   │   ├── schema_test.py
│   │   ├── scope.py
│   │   ├── scope_test.py
│   │   ├── session.py
│   │   ├── session_test.py
│   │   ├── sparse_to_dense_mask_test.py
│   │   ├── sparse_to_dense_test.py
│   │   ├── task.py
│   │   ├── test/
│   │   │   ├── blob_deallocation_test.py
│   │   │   ├── do_op_test.py
│   │   │   ├── executor_test.py
│   │   │   └── executor_test_util.py
│   │   ├── test_util.py
│   │   ├── text_file_reader.py
│   │   ├── timeout_guard.py
│   │   ├── toy_regression_test.py
│   │   ├── tt_core.py
│   │   ├── tt_core_test.py
│   │   ├── tutorials/
│   │   │   ├── Basics.ipynb
│   │   │   ├── Control_Ops.ipynb
│   │   │   ├── Getting_Caffe1_Models_for_Translation.ipynb
│   │   │   ├── Image_Pre-Processing_Pipeline.ipynb
│   │   │   ├── Loading_Pretrained_Models.ipynb
│   │   │   ├── MNIST.ipynb
│   │   │   ├── MNIST_Dataset_and_Databases.ipynb
│   │   │   ├── Model_Quickload.ipynb
│   │   │   ├── Multi-GPU_Training.ipynb
│   │   │   ├── Python_Op.ipynb
│   │   │   ├── README.md
│   │   │   ├── Toy_Regression.ipynb
│   │   │   ├── Training_a_Model.ipynb
│   │   │   ├── create_your_own_dataset.ipynb
│   │   │   ├── experimental/
│   │   │   │   └── Immediate.ipynb
│   │   │   ├── helpers.py
│   │   │   ├── inference_codes.txt
│   │   │   ├── jupyter_notebook_config.py
│   │   │   ├── py_gen/
│   │   │   │   ├── Basics.py
│   │   │   │   ├── Control_Ops.py
│   │   │   │   ├── Getting_Caffe1_Models_for_Translation.py
│   │   │   │   ├── Image_Pre-Processing_Pipeline.py
│   │   │   │   ├── Loading_Pretrained_Models.py
│   │   │   │   ├── MNIST.py
│   │   │   │   ├── MNIST_Dataset_and_Databases.py
│   │   │   │   ├── Model_Quickload.py
│   │   │   │   ├── Multi-GPU_Training.py
│   │   │   │   ├── Python_Op.py
│   │   │   │   ├── Toy_Regression.py
│   │   │   │   ├── Training_a_Model.py
│   │   │   │   ├── create_your_own_dataset.py
│   │   │   │   └── sparseNN.py
│   │   │   ├── start_ipython_notebook.sh
│   │   │   └── tutorials_to_script_converter.py
│   │   ├── utils.py
│   │   ├── visualize.py
│   │   ├── workspace.py
│   │   └── workspace_test.py
│   ├── queue/
│   │   ├── CMakeLists.txt
│   │   ├── blobs_queue.cc
│   │   ├── blobs_queue.h
│   │   ├── blobs_queue_db.cc
│   │   ├── blobs_queue_db.h
│   │   ├── queue_ops.cc
│   │   ├── queue_ops.h
│   │   ├── queue_ops_gpu.cc
│   │   ├── rebatching_queue.cc
│   │   ├── rebatching_queue.h
│   │   ├── rebatching_queue_ops.cc
│   │   └── rebatching_queue_ops.h
│   ├── sgd/
│   │   ├── CMakeLists.txt
│   │   ├── adagrad_op.cc
│   │   ├── adagrad_op.h
│   │   ├── adagrad_op_gpu.cu
│   │   ├── adam_op.cc
│   │   ├── adam_op.h
│   │   ├── adam_op_gpu.cu
│   │   ├── clip_tensor_op.cc
│   │   ├── clip_tensor_op.h
│   │   ├── fp16_momentum_sgd_op.cu
│   │   ├── fp16_momentum_sgd_op.h
│   │   ├── fp32_momentum_sgd_op.cu
│   │   ├── fp32_momentum_sgd_op.h
│   │   ├── ftrl_op.cc
│   │   ├── ftrl_op.h
│   │   ├── iter_op.cc
│   │   ├── iter_op.h
│   │   ├── iter_op_gpu.cc
│   │   ├── lars_op.cc
│   │   ├── lars_op.h
│   │   ├── lars_op_gpu.cu
│   │   ├── learning_rate_functors.h
│   │   ├── learning_rate_op.cc
│   │   ├── learning_rate_op.h
│   │   ├── learning_rate_op_gpu.cc
│   │   ├── momentum_sgd_op.cc
│   │   ├── momentum_sgd_op.h
│   │   ├── momentum_sgd_op_gpu.cu
│   │   ├── rmsprop_op.cc
│   │   ├── rmsprop_op.h
│   │   ├── rmsprop_op_gpu.cu
│   │   ├── yellowfin_op.cc
│   │   ├── yellowfin_op.h
│   │   └── yellowfin_op_gpu.cu
│   ├── share/
│   │   ├── CMakeLists.txt
│   │   └── contrib/
│   │       ├── CMakeLists.txt
│   │       ├── nnpack/
│   │       │   ├── CMakeLists.txt
│   │       │   ├── conv_op.cc
│   │       │   └── conv_op_test.cc
│   │       └── zstd/
│   │           ├── CMakeLists.txt
│   │           ├── quant_decomp_zstd_op.cc
│   │           └── quant_decomp_zstd_op.h
│   ├── test/
│   │   ├── assets/
│   │   │   └── squeeze_predict_net.pb
│   │   └── caffe2_gtest_main.cc
│   ├── transforms/
│   │   ├── CMakeLists.txt
│   │   ├── common_subexpression_elimination.cc
│   │   ├── common_subexpression_elimination.h
│   │   ├── common_subexpression_elimination_test.cc
│   │   ├── conv_to_nnpack_transform.cc
│   │   ├── conv_to_nnpack_transform.h
│   │   ├── conv_to_nnpack_transform_test.cc
│   │   ├── pattern_net_transform.cc
│   │   ├── pattern_net_transform.h
│   │   ├── pattern_net_transform_test.cc
│   │   ├── single_op_transform.cc
│   │   └── single_op_transform.h
│   ├── utils/
│   │   ├── CMakeLists.txt
│   │   ├── GpuBitonicSort.cuh
│   │   ├── GpuDefs.cuh
│   │   ├── GpuScanUtils.cuh
│   │   ├── cast.h
│   │   ├── cblas.h
│   │   ├── conversions.h
│   │   ├── cpu_neon.h
│   │   ├── cpuid.cc
│   │   ├── cpuid.h
│   │   ├── cpuid_test.cc
│   │   ├── eigen_utils.h
│   │   ├── fatal_signal_asan_no_sig_test.cc
│   │   ├── fixed_divisor.h
│   │   ├── fixed_divisor_test.cc
│   │   ├── math-detail.h
│   │   ├── math.h
│   │   ├── math_cpu.cc
│   │   ├── math_gpu.cu
│   │   ├── math_gpu_test.cc
│   │   ├── math_test.cc
│   │   ├── mixed_utils.h
│   │   ├── murmur_hash3.cc
│   │   ├── murmur_hash3.h
│   │   ├── proto_utils.cc
│   │   ├── proto_utils.h
│   │   ├── proto_utils_test.cc
│   │   ├── signal_handler.cc
│   │   ├── signal_handler.h
│   │   ├── simple_queue.h
│   │   ├── simple_queue_test.cc
│   │   ├── smart_tensor_printer.cc
│   │   ├── smart_tensor_printer.h
│   │   ├── smart_tensor_printer_test.cc
│   │   ├── string_utils.cc
│   │   ├── string_utils.h
│   │   ├── thread_pool.h
│   │   ├── threadpool/
│   │   │   ├── ThreadPool.cc
│   │   │   ├── ThreadPool.h
│   │   │   ├── ThreadPoolCommon.h
│   │   │   ├── WorkersPool.h
│   │   │   ├── pthreadpool.cc
│   │   │   ├── pthreadpool.h
│   │   │   ├── pthreadpool_impl.cc
│   │   │   └── pthreadpool_impl.h
│   │   └── zmq_helper.h
│   └── video/
│       ├── CMakeLists.txt
│       ├── optical_flow.cc
│       ├── optical_flow.h
│       ├── video_decoder.cc
│       ├── video_decoder.h
│       ├── video_input_op.cc
│       ├── video_input_op.h
│       ├── video_input_op_gpu.cc
│       ├── video_io.cc
│       └── video_io.h
├── cmake/
│   ├── BuildVariables.cmake
│   ├── Caffe2Config.cmake.in
│   ├── Caffe2ConfigVersion.cmake.in
│   ├── Dependencies.cmake
│   ├── External/
│   │   ├── nccl.cmake
│   │   └── nnpack.cmake
│   ├── MiscCheck.cmake
│   ├── Modules/
│   │   ├── FindAtlas.cmake
│   │   ├── FindBenchmark.cmake
│   │   ├── FindCUB.cmake
│   │   ├── FindFFmpeg.cmake
│   │   ├── FindGloo.cmake
│   │   ├── FindHiredis.cmake
│   │   ├── FindLAPACK.cmake
│   │   ├── FindLMDB.cmake
│   │   ├── FindLevelDB.cmake
│   │   ├── FindMKL.cmake
│   │   ├── FindMatlabMex.cmake
│   │   ├── FindNCCL.cmake
│   │   ├── FindNNPACK.cmake
│   │   ├── FindNumPy.cmake
│   │   ├── FindNuma.cmake
│   │   ├── FindOpenBLAS.cmake
│   │   ├── FindRocksDB.cmake
│   │   ├── FindSnappy.cmake
│   │   ├── FindZMQ.cmake
│   │   ├── Findpybind11.cmake
│   │   └── FindvecLib.cmake
│   ├── Modules_CUDA_fix/
│   │   ├── FindCUDA/
│   │   │   ├── make2cmake.cmake
│   │   │   ├── parse_cubin.cmake
│   │   │   ├── run_nvcc.cmake
│   │   │   └── select_compute_arch.cmake
│   │   ├── FindCUDA.cmake
│   │   ├── FindPackageHandleStandardArgs.cmake
│   │   ├── FindPackageMessage.cmake
│   │   └── README.txt
│   ├── ProtoBuf.cmake
│   ├── Summary.cmake
│   ├── Utils.cmake
│   ├── Whitelist.cmake
│   ├── cmake_uninstall.cmake.in
│   └── public/
│       ├── cuda.cmake
│       ├── gflags.cmake
│       ├── glog.cmake
│       ├── protobuf.cmake
│       ├── threads.cmake
│       └── utils.cmake
├── conda/
│   ├── cuda/
│   │   ├── build.sh
│   │   ├── conda_build_config.yaml
│   │   └── meta.yaml
│   ├── cuda_full/
│   │   ├── build.sh
│   │   ├── conda_build_config.yaml
│   │   └── meta.yaml
│   └── no_cuda/
│       ├── build.sh
│       ├── conda_build_config.yaml
│       └── meta.yaml
├── docker/
│   ├── jenkins/
│   │   ├── README.md
│   │   ├── build.sh
│   │   ├── centos/
│   │   │   ├── .gitignore
│   │   │   └── Dockerfile
│   │   ├── centos-cuda/
│   │   │   ├── .gitignore
│   │   │   └── Dockerfile
│   │   ├── common/
│   │   │   ├── add_jenkins_user.sh
│   │   │   ├── install_anaconda.sh
│   │   │   ├── install_android.sh
│   │   │   ├── install_base.sh
│   │   │   ├── install_ccache.sh
│   │   │   ├── install_clang.sh
│   │   │   ├── install_cmake.sh
│   │   │   ├── install_cuda.sh
│   │   │   ├── install_gcc.sh
│   │   │   ├── install_mkl.sh
│   │   │   ├── install_nccl.sh
│   │   │   └── install_python.sh
│   │   ├── ubuntu/
│   │   │   ├── .gitignore
│   │   │   └── Dockerfile
│   │   └── ubuntu-cuda/
│   │       ├── .gitignore
│   │       └── Dockerfile
│   ├── readme.md
│   ├── ubuntu-14.04-cpu-all-options/
│   │   └── Dockerfile
│   ├── ubuntu-14.04-cpu-minimal/
│   │   └── Dockerfile
│   ├── ubuntu-16.04-cpu-all-options/
│   │   └── Dockerfile
│   ├── ubuntu-16.04-cpu-minimal/
│   │   └── Dockerfile
│   ├── ubuntu-16.04-cuda8-cudnn6-all-options/
│   │   └── Dockerfile
│   ├── ubuntu-16.04-cuda8-cudnn7-all-options/
│   │   └── Dockerfile
│   └── ubuntu-16.04-gpu-tutorial/
│       └── Dockerfile
├── docs/
│   ├── .Doxyfile-c
│   ├── .Doxyfile-python
│   ├── DOXYGEN.md
│   ├── DoxygenLayout-c.xml
│   ├── DoxygenLayout-python.xml
│   ├── README.md
│   ├── footer.html
│   ├── header.html
│   ├── installation.md
│   ├── main.css
│   ├── process.py
│   └── stylesheet.css
├── modules/
│   ├── CMakeLists.txt
│   ├── detectron/
│   │   ├── CMakeLists.txt
│   │   ├── affine_channel_op.cc
│   │   ├── affine_channel_op.cu
│   │   ├── affine_channel_op.h
│   │   ├── batch_permutation_op.cc
│   │   ├── batch_permutation_op.cu
│   │   ├── batch_permutation_op.h
│   │   ├── group_spatial_softmax_op.cc
│   │   ├── group_spatial_softmax_op.cu
│   │   ├── group_spatial_softmax_op.h
│   │   ├── ps_roi_pool_op.cc
│   │   ├── ps_roi_pool_op.cu
│   │   ├── ps_roi_pool_op.h
│   │   ├── roi_pool_f_op.cc
│   │   ├── roi_pool_f_op.cu
│   │   ├── roi_pool_f_op.h
│   │   ├── sample_as_op.cc
│   │   ├── sample_as_op.cu
│   │   ├── sample_as_op.h
│   │   ├── select_smooth_l1_loss_op.cc
│   │   ├── select_smooth_l1_loss_op.cu
│   │   ├── select_smooth_l1_loss_op.h
│   │   ├── sigmoid_cross_entropy_loss_op.cc
│   │   ├── sigmoid_cross_entropy_loss_op.cu
│   │   ├── sigmoid_cross_entropy_loss_op.h
│   │   ├── sigmoid_focal_loss_op.cc
│   │   ├── sigmoid_focal_loss_op.cu
│   │   ├── sigmoid_focal_loss_op.h
│   │   ├── smooth_l1_loss_op.cc
│   │   ├── smooth_l1_loss_op.cu
│   │   ├── smooth_l1_loss_op.h
│   │   ├── softmax_focal_loss_op.cc
│   │   ├── softmax_focal_loss_op.cu
│   │   ├── softmax_focal_loss_op.h
│   │   ├── spatial_narrow_as_op.cc
│   │   ├── spatial_narrow_as_op.cu
│   │   ├── spatial_narrow_as_op.h
│   │   ├── upsample_nearest_op.cc
│   │   ├── upsample_nearest_op.cu
│   │   └── upsample_nearest_op.h
│   ├── module_test/
│   │   ├── CMakeLists.txt
│   │   └── module_test_dynamic.cc
│   ├── observers/
│   │   ├── CMakeLists.txt
│   │   ├── net_observer_reporter.h
│   │   ├── net_observer_reporter_print.cc
│   │   ├── net_observer_reporter_print.h
│   │   ├── observer_config.cc
│   │   ├── observer_config.h
│   │   ├── perf_observer.cc
│   │   └── perf_observer.h
│   └── rocksdb/
│       ├── CMakeLists.txt
│       └── rocksdb.cc
├── release-notes.md
├── scripts/
│   ├── add_apache_header.sh
│   ├── apache_header.txt
│   ├── appveyor/
│   │   ├── install.bat
│   │   └── install_cuda.bat
│   ├── diagnose_protobuf.py
│   ├── get_python_cmake_flags.py
│   ├── read_conda_versions.sh
│   ├── start_ipython_notebook.sh
│   └── temp.sh
└── setup.py

SYMBOL INDEX (9818 symbols across 1431 files)

FILE: binaries/caffe2_benchmark.cc
  function writeTextOutput (line 77) | static void writeTextOutput(
  function main (line 114) | int main(int argc, char** argv) {

FILE: binaries/convert_caffe_image_db.cc
  function main (line 35) | int main(int argc, char** argv) {

FILE: binaries/convert_db.cc
  function main (line 32) | int main(int argc, char** argv) {

FILE: binaries/convert_encoded_to_raw_leveldb.cc
  type caffe2 (line 47) | namespace caffe2 {
    function ConvertToRawDataset (line 52) | void ConvertToRawDataset(
  function main (line 151) | int main(int argc, char** argv) {

FILE: binaries/core_overhead_benchmark.cc
  function BM_CUDAContextCreation (line 31) | static void BM_CUDAContextCreation(benchmark::State& state) {
  function BM_CUDAContextStreamAccess (line 40) | static void BM_CUDAContextStreamAccess(benchmark::State& state) {
  function BM_cudaGetDevice (line 49) | static void BM_cudaGetDevice(benchmark::State& state) {
  function BM_cudaSetDevice (line 58) | static void BM_cudaSetDevice(benchmark::State& state) {
  function BM_cudaSetAndGetDevice (line 68) | static void BM_cudaSetAndGetDevice(benchmark::State& state) {
  function BM_cudaSetSameDevice (line 80) | static void BM_cudaSetSameDevice(benchmark::State& state) {
  function BM_cudaStreamCreateSyncDelete (line 88) | static void BM_cudaStreamCreateSyncDelete(benchmark::State& state) {
  function BM_cudaStreamSynchronize (line 99) | static void BM_cudaStreamSynchronize(benchmark::State& state) {
  function BM_cudaEventRecord (line 109) | static void BM_cudaEventRecord(benchmark::State& state) {
  function BM_cudaStreamWaitEventThenStreamSynchronize (line 122) | static void BM_cudaStreamWaitEventThenStreamSynchronize(
  function BM_CudaPointerAffinity (line 140) | static void BM_CudaPointerAffinity(benchmark::State& state) {
  class DummyEmptyOp (line 152) | class DummyEmptyOp : public Operator<Context> {
    method DummyEmptyOp (line 154) | DummyEmptyOp(const OperatorDef& def, Workspace* ws)
    method RunOnDevice (line 157) | bool RunOnDevice() final { return true; }
  function BM_OperatorCreationCPU (line 165) | static void BM_OperatorCreationCPU(benchmark::State& state) {
  function BM_OperatorCreationCUDA (line 177) | static void BM_OperatorCreationCUDA(benchmark::State& state) {
  function BM_RawAllocDeallocCPU (line 190) | static void BM_RawAllocDeallocCPU(benchmark::State& state) {
  function BM_TensorAllocDeallocCPU (line 200) | static void BM_TensorAllocDeallocCPU(benchmark::State& state) {
  function BM_TensorAllocDeallocCUDA (line 211) | static void BM_TensorAllocDeallocCUDA(benchmark::State& state) {

FILE: binaries/db_throughput.cc
  function TestThroughputWithDB (line 39) | void TestThroughputWithDB() {
  function TestThroughputWithReaderWorker (line 61) | void TestThroughputWithReaderWorker(const DBReader* reader, int thread_i...
  function TestThroughputWithReader (line 76) | void TestThroughputWithReader() {
  function main (line 90) | int main(int argc, char** argv) {

FILE: binaries/inspect_gpus.cc
  function main (line 30) | int main(int argc, char** argv) {

FILE: binaries/make_cifar_db.cc
  type caffe2 (line 45) | namespace caffe2 {
    function ReadImage (line 58) | void ReadImage(std::ifstream* file, int* label, char* buffer) {
    function WriteToDB (line 79) | void WriteToDB(const string& filename, const int num_items,
    function ConvertCIFAR (line 111) | void ConvertCIFAR() {
  function main (line 144) | int main(int argc, char** argv) {

FILE: binaries/make_image_db.cc
  type caffe2 (line 67) | namespace caffe2 {
    class Converter (line 69) | class Converter {
      method Converter (line 71) | explicit Converter() {
      method queue (line 97) | void queue(const std::pair<std::string, int>& pair) {
      method start (line 101) | void start() {
      method get (line 105) | std::string get() {
      method run (line 117) | void run() {
    function ConvertImageDataset (line 201) | void ConvertImageDataset(
  function main (line 274) | int main(int argc, char** argv) {

FILE: binaries/make_mnist_db.cc
  type caffe2 (line 40) | namespace caffe2 {
    function swap_endian (line 41) | uint32_t swap_endian(uint32_t val) {
    function convert_dataset (line 46) | void convert_dataset(const char* image_filename, const char* label_fil...
  function main (line 134) | int main(int argc, char** argv) {

FILE: binaries/predictor_verifier.cc
  type caffe2 (line 28) | namespace caffe2 {
    function run (line 30) | void run() {
  function main (line 51) | int main(int argc, char** argv) {

FILE: binaries/print_core_object_sizes.cc
  function main (line 29) | int main(int /* unused */, char** /* unused */) {

FILE: binaries/print_registered_core_operators.cc
  function HasSchema (line 27) | static bool HasSchema(const std::string& str) {
  function HasDoc (line 31) | static bool HasDoc(const std::string& str) {
  function main (line 36) | int main(int argc, char** argv) {

FILE: binaries/run_plan.cc
  function main (line 25) | int main(int argc, char** argv) {

FILE: binaries/run_plan_mpi.cc
  function main (line 27) | int main(int argc, char** argv) {

FILE: binaries/speed_benchmark.cc
  function main (line 79) | int main(int argc, char** argv) {

FILE: binaries/split_db.cc
  type caffe2 (line 30) | namespace caffe2 {
    function Split (line 32) | static int Split(int argc, char** argv) {
  function main (line 75) | int main(int argc, char** argv) {

FILE: binaries/tutorial_blob.cc
  function main (line 26) | int main(int argc, char** argv) {

FILE: binaries/zmq_feeder.cc
  function main (line 34) | int main(int argc, char** argv) {

FILE: caffe2/contrib/aten/aten_op.cc
  type caffe2 (line 20) | namespace caffe2 {
    type math (line 31) | namespace math {

FILE: caffe2/contrib/aten/aten_op_cuda.cc
  type caffe2 (line 20) | namespace caffe2 {
    type math (line 28) | namespace math {

FILE: caffe2/contrib/aten/aten_op_template.h
  function namespace (line 33) | namespace caffe2 {

FILE: caffe2/contrib/aten/aten_test.py
  class TestATen (line 32) | class TestATen(hu.HypothesisTestCase):
    method test_add (line 35) | def test_add(self, inputs, gc, dc):
    method test_pow (line 47) | def test_pow(self, inputs, gc, dc):
    method test_sort (line 60) | def test_sort(self, x, gc, dc):
    method test_sum (line 73) | def test_sum(self, inputs, gc, dc):
    method test_ones (line 86) | def test_ones(self, gc, dc):

FILE: caffe2/contrib/aten/docs/sample.py
  class MyFunction (line 10) | class MyFunction(Function):
    method forward (line 12) | def forward(ctx, x, y):
    method symbolic (line 15) | def symbolic(graph, x, y):
  class MyModule (line 23) | class MyModule(nn.Module):
    method forward (line 24) | def forward(self, x, y):

FILE: caffe2/contrib/aten/gen_op.py
  function write (line 51) | def write(filename, s):
  function read (line 56) | def read(filename):
  function value_has_tensors (line 61) | def value_has_tensors(v):
  function value_is_tensor_type (line 66) | def value_is_tensor_type(v):
  function expand (line 94) | def expand(o):
  function supports (line 107) | def supports(o):
  function get_output (line 153) | def get_output(o, i):
  function attribute_names (line 160) | def attribute_names(o):
  function required_attribute_names (line 164) | def required_attribute_names(o):
  function self_as_first_argument (line 168) | def self_as_first_argument(arguments):
  function get_num_inputs (line 173) | def get_num_inputs(o):

FILE: caffe2/contrib/cuda-convnet2/convdata.py
  class JPEGBatchLoaderThread (line 29) | class JPEGBatchLoaderThread(Thread):
    method __init__ (line 30) | def __init__(self, dp, batch_num, label_offset, list_out):
    method load_jpeg_batch (line 38) | def load_jpeg_batch(rawdics, dp, label_offset):
    method run (line 59) | def run(self):
  class ColorNoiseMakerThread (line 66) | class ColorNoiseMakerThread(Thread):
    method __init__ (line 67) | def __init__(self, pca_stdevs, pca_vecs, num_noise, list_out):
    method run (line 73) | def run(self):
  class ImageDataProvider (line 77) | class ImageDataProvider(LabeledDataProvider):
    method __init__ (line 78) | def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batc...
    method showimg (line 109) | def showimg(self, img):
    method get_data_dims (line 117) | def get_data_dims(self, idx=0):
    method start_loader (line 124) | def start_loader(self, batch_idx):
    method start_color_noise_maker (line 132) | def start_color_noise_maker(self):
    method set_labels (line 138) | def set_labels(self, datadic):
    method get_data_from_loader (line 141) | def get_data_from_loader(self):
    method add_color_noise (line 158) | def add_color_noise(self):
    method get_next_batch (line 185) | def get_next_batch(self):
    method get_plottable_data (line 205) | def get_plottable_data(self, data, add_mean=True):
  class CIFARDataProvider (line 209) | class CIFARDataProvider(LabeledDataProvider):
    method __init__ (line 210) | def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batc...
    method get_next_batch (line 232) | def get_next_batch(self):
    method get_data_dims (line 244) | def get_data_dims(self, idx=0):
    method get_plottable_data (line 251) | def get_plottable_data(self, data):
    method __trim_borders (line 254) | def __trim_borders(self, x, target):
  class DummyConvNetLogRegDataProvider (line 277) | class DummyConvNetLogRegDataProvider(LabeledDummyDataProvider):
    method __init__ (line 278) | def __init__(self, data_dim):
    method get_next_batch (line 283) | def get_next_batch(self):
    method get_data_dims (line 290) | def get_data_dims(self, idx=0):

FILE: caffe2/contrib/cuda-convnet2/convnet.py
  class Driver (line 30) | class Driver(object):
    method __init__ (line 31) | def __init__(self, convnet):
    method on_start_batch (line 34) | def on_start_batch(self, batch_data, train):
    method on_finish_batch (line 37) | def on_finish_batch(self):
  class GradCheckDriver (line 40) | class GradCheckDriver(Driver):
    method on_start_batch (line 41) | def on_start_batch(self, batch_data, train):
  class TrainingDriver (line 45) | class TrainingDriver(Driver):
    method on_start_batch (line 46) | def on_start_batch(self, batch_data, train):
  class MultiviewTestDriver (line 50) | class MultiviewTestDriver(TrainingDriver):
    method on_start_batch (line 51) | def on_start_batch(self, batch_data, train):
    method on_finish_batch (line 66) | def on_finish_batch(self):
  class FeatureWriterDriver (line 73) | class FeatureWriterDriver(Driver):
    method __init__ (line 74) | def __init__(self, convnet):
    method on_start_batch (line 78) | def on_start_batch(self, batch_data, train):
    method on_finish_batch (line 91) | def on_finish_batch(self):
  class ConvNet (line 100) | class ConvNet(IGPUModel):
    method __init__ (line 101) | def __init__(self, op, load_dic, dp_params={}):
    method import_model (line 108) | def import_model(self):
    method init_model_lib (line 114) | def init_model_lib(self):
    method init_model_state (line 120) | def init_model_state(self):
    method do_decouple_conv (line 134) | def do_decouple_conv(self):
    method do_unshare_weights (line 141) | def do_unshare_weights(self):
    method set_driver (line 156) | def set_driver(self):
    method fill_excused_options (line 166) | def fill_excused_options(self):
    method parse_batch_data (line 174) | def parse_batch_data(self, batch_data, train=True):
    method start_batch (line 179) | def start_batch(self, batch_data, train=True):
    method finish_batch (line 182) | def finish_batch(self):
    method print_iteration (line 187) | def print_iteration(self):
    method print_train_time (line 190) | def print_train_time(self, compute_time_py):
    method print_costs (line 193) | def print_costs(self, cost_outputs):
    method print_train_results (line 215) | def print_train_results(self):
    method print_test_status (line 218) | def print_test_status(self):
    method print_test_results (line 221) | def print_test_results(self):
    method conditional_save (line 237) | def conditional_save(self):
    method aggregate_test_outputs (line 240) | def aggregate_test_outputs(self, test_outputs):
    method get_options_parser (line 251) | def get_options_parser(cls):

FILE: caffe2/contrib/cuda-convnet2/cudaconvnet/include/jpeg.h
  function class (line 38) | class DecoderThread : public Thread {

FILE: caffe2/contrib/cuda-convnet2/cudaconvnet/src/jpeg.cpp
  type jpeg_decompress_struct (line 70) | struct jpeg_decompress_struct
  type jpeg_error_mgr (line 71) | struct jpeg_error_mgr

FILE: caffe2/contrib/cuda-convnet2/initw.py
  function get_src (line 19) | def get_src(filename):
  function makew (line 24) | def makew(name, idx, shape, params):
  function makeb (line 29) | def makeb(name, shape, params):
  function concat (line 33) | def concat(shape, src, src_layers, src_func):
  function makewcat (line 43) | def makewcat(name, idx, shape, params):
  function makebcat (line 48) | def makebcat(name, shape, params):
  function makeb_vec (line 53) | def makeb_vec(name, shape, params):

FILE: caffe2/contrib/cuda-convnet2/layer.py
  class LayerParsingError (line 27) | class LayerParsingError(Exception):
  class NeuronParser (line 31) | class NeuronParser:
    method __init__ (line 32) | def __init__(self, type, func_str, uses_acts=True, uses_inputs=True):
    method parse (line 38) | def parse(self, type):
  class ParamNeuronParser (line 47) | class ParamNeuronParser(NeuronParser):
    method __init__ (line 49) | def __init__(self, type, func_str, uses_acts=True, uses_inputs=True):
    method parse (line 56) | def parse(self, type):
  class AbsTanhNeuronParser (line 70) | class AbsTanhNeuronParser(ParamNeuronParser):
    method __init__ (line 71) | def __init__(self):
    method parse (line 74) | def parse(self, type):
  class ParamParser (line 82) | class ParamParser:
    method __init__ (line 86) | def __init__(self, type):
    method parse (line 96) | def parse(self, type):
  class MyConfigParser (line 109) | class MyConfigParser(cfg.SafeConfigParser):
    method safe_get (line 110) | def safe_get(self, section, option, f=cfg.SafeConfigParser.get, typest...
    method safe_get_list (line 122) | def safe_get_list(self, section, option, f=str, typestr='strings', def...
    method safe_get_int (line 131) | def safe_get_int(self, section, option, default=None):
    method safe_get_float (line 134) | def safe_get_float(self, section, option, default=None):
    method safe_get_bool (line 137) | def safe_get_bool(self, section, option, default=None):
    method safe_get_float_list (line 140) | def safe_get_float_list(self, section, option, default=None):
    method safe_get_int_list (line 143) | def safe_get_int_list(self, section, option, default=None):
    method safe_get_bool_list (line 146) | def safe_get_bool_list(self, section, option, default=None):
  class FakeConfigParser (line 150) | class FakeConfigParser(object):
    method __init__ (line 151) | def __init__(self, dic):
    method safe_get (line 154) | def safe_get(self, section, option, default=None):
    method safe_get_int (line 159) | def safe_get_int(self, section, option, default=None):
    method safe_get_int_list (line 162) | def safe_get_int_list(self, section, option, default=None):
  class LayerParser (line 165) | class LayerParser:
    method __init__ (line 166) | def __init__(self):
    method optimize (line 171) | def optimize(self, layers):
    method parse_params (line 178) | def parse_params(self, vals, parsers, param_name, human_name, num_para...
    method add_params (line 200) | def add_params(self, mcp):
    method init (line 204) | def init(self, dic):
    method set_defaults (line 208) | def set_defaults(self):
    method parse (line 247) | def parse(self, name, mcp, prev_layers, model=None):
    method verify_float_range (line 255) | def verify_float_range(self, v, param_name, _min, _max):
    method verify_num_range (line 258) | def verify_num_range(self, v, param_name, _min, _max, strconv=lambda x...
    method _verify_num_range (line 265) | def _verify_num_range(self, v, param_name, _min, _max, input=-1, strco...
    method verify_divisible (line 274) | def verify_divisible(self, value, div, value_name, div_name=None, inpu...
    method verify_str_in (line 279) | def verify_str_in(self, value, param_name, lst, input_idx=-1):
    method verify_int_in (line 284) | def verify_int_in(self, value, param_name, lst):
    method verify_all_ints_in (line 288) | def verify_all_ints_in(self, values, param_name, lst):
    method verify_input_dims (line 292) | def verify_input_dims(self, dims):
    method detach_neuron_layers (line 300) | def detach_neuron_layers(layers):
    method parse_layers (line 306) | def parse_layers(layer_cfg_path, param_cfg_path, model, layers={}):
    method register_layer_parser (line 348) | def register_layer_parser(ltype, cls):
  class LayerWithInputParser (line 354) | class LayerWithInputParser(LayerParser):
    method __init__ (line 355) | def __init__(self, num_inputs=-1):
    method verify_num_params (line 359) | def verify_num_params(self, params, auto_expand=True):
    method optimize (line 368) | def optimize(self, layers):
    method parse (line 395) | def parse(self, name, mcp, prev_layers, model=None):
    method verify_img_size (line 440) | def verify_img_size(self):
    method grad_consumers_below (line 446) | def grad_consumers_below(dic):
    method verify_no_grads (line 452) | def verify_no_grads(self):
  class NailbedLayerParser (line 456) | class NailbedLayerParser(LayerWithInputParser):
    method __init__ (line 457) | def __init__(self):
    method parse (line 460) | def parse(self, name, mcp, prev_layers, model=None):
  class GaussianBlurLayerParser (line 485) | class GaussianBlurLayerParser(LayerWithInputParser):
    method __init__ (line 486) | def __init__(self):
    method parse (line 489) | def parse(self, name, mcp, prev_layers, model=None):
  class HorizontalReflectionLayerParser (line 518) | class HorizontalReflectionLayerParser(LayerWithInputParser):
    method __init__ (line 519) | def __init__(self):
    method parse (line 522) | def parse(self, name, mcp, prev_layers, model=None):
  class ResizeLayerParser (line 538) | class ResizeLayerParser(LayerWithInputParser):
    method __init__ (line 539) | def __init__(self):
    method parse (line 542) | def parse(self, name, mcp, prev_layers, model=None):
  class RandomScaleLayerParser (line 568) | class RandomScaleLayerParser(LayerWithInputParser):
    method __init__ (line 569) | def __init__(self):
    method parse (line 572) | def parse(self, name, mcp, prev_layers, model=None):
  class CropLayerParser (line 606) | class CropLayerParser(LayerWithInputParser):
    method __init__ (line 607) | def __init__(self):
    method parse (line 610) | def parse(self, name, mcp, prev_layers, model=None):
  class ColorTransformLayerParser (line 641) | class ColorTransformLayerParser(LayerWithInputParser):
    method __init__ (line 642) | def __init__(self):
    method parse (line 645) | def parse(self, name, mcp, prev_layers, model=None):
  class RGBToYUVLayerParser (line 662) | class RGBToYUVLayerParser(ColorTransformLayerParser):
    method __init__ (line 663) | def __init__(self):
    method parse (line 666) | def parse(self, name, mcp, prev_layers, model=None):
  class RGBToLABLayerParser (line 671) | class RGBToLABLayerParser(ColorTransformLayerParser):
    method __init__ (line 672) | def __init__(self):
    method parse (line 675) | def parse(self, name, mcp, prev_layers, model=None):
  class NeuronLayerParser (line 681) | class NeuronLayerParser(LayerWithInputParser):
    method __init__ (line 682) | def __init__(self):
    method get_unused_layer_name (line 686) | def get_unused_layer_name(layers, wish):
    method parse_neuron (line 695) | def parse_neuron(self, neuron_str):
    method detach_neuron_layer (line 714) | def detach_neuron_layer(self, src_name, layers):
    method parse (line 734) | def parse(self, name, mcp, prev_layers, model=None):
  class EltwiseSumLayerParser (line 742) | class EltwiseSumLayerParser(LayerWithInputParser):
    method __init__ (line 743) | def __init__(self):
    method add_params (line 746) | def add_params(self, mcp):
    method parse (line 751) | def parse(self, name, mcp, prev_layers, model):
  class EltwiseMaxLayerParser (line 765) | class EltwiseMaxLayerParser(LayerWithInputParser):
    method __init__ (line 766) | def __init__(self):
    method parse (line 769) | def parse(self, name, mcp, prev_layers, model):
  class SumLayerParser (line 780) | class SumLayerParser(LayerWithInputParser):
    method __init__ (line 781) | def __init__(self):
    method parse (line 784) | def parse(self, name, mcp, prev_layers, model):
  class DropoutLayerParser (line 794) | class DropoutLayerParser(LayerWithInputParser):
    method __init__ (line 795) | def __init__(self):
    method add_params (line 798) | def add_params(self, mcp):
    method parse (line 804) | def parse(self, name, mcp, prev_layers, model):
  class Dropout2LayerParser (line 815) | class Dropout2LayerParser(DropoutLayerParser):
    method __init__ (line 816) | def __init__(self):
  class WeightLayerParser (line 819) | class WeightLayerParser(LayerWithInputParser):
    method __init__ (line 822) | def __init__(self, num_inputs=-1):
    method get_layer_name (line 826) | def get_layer_name(name_str):
    method add_params (line 832) | def add_params(self, mcp):
    method unshare_weights (line 864) | def unshare_weights(layer, layers, matrix_idx=None):
    method call_init_func (line 880) | def call_init_func(self, param_name, shapes, input_idx=-1):
    method make_weights (line 894) | def make_weights(self, initW, rows, cols, order='C'):
    method make_biases (line 927) | def make_biases(self, rows, cols, order='C'):
    method parse (line 944) | def parse(self, name, mcp, prev_layers, model):
  class FCLayerParser (line 991) | class FCLayerParser(WeightLayerParser):
    method __init__ (line 992) | def __init__(self):
    method parse (line 995) | def parse(self, name, mcp, prev_layers, model):
  class SplitFCLayerParser (line 1007) | class SplitFCLayerParser(WeightLayerParser):
    method __init__ (line 1008) | def __init__(self):
    method parse (line 1011) | def parse(self, name, mcp, prev_layers, model):
  class LocalLayerParser (line 1027) | class LocalLayerParser(WeightLayerParser):
    method __init__ (line 1028) | def __init__(self):
    method conv_to_local (line 1033) | def conv_to_local(layers, lname):
    method parse (line 1062) | def parse(self, name, mcp, prev_layers, model):
  class ConvLayerParser (line 1134) | class ConvLayerParser(LocalLayerParser):
    method __init__ (line 1135) | def __init__(self):
    method add_params (line 1138) | def add_params(self, mcp):
    method parse (line 1147) | def parse(self, name, mcp, prev_layers, model):
  class LocalUnsharedLayerParser (line 1162) | class LocalUnsharedLayerParser(LocalLayerParser):
    method __init__ (line 1163) | def __init__(self):
    method parse (line 1166) | def parse(self, name, mcp, prev_layers, model):
  class DataLayerParser (line 1176) | class DataLayerParser(LayerParser):
    method __init__ (line 1177) | def __init__(self):
    method parse (line 1180) | def parse(self, name, mcp, prev_layers, model):
  class SoftmaxLayerParser (line 1190) | class SoftmaxLayerParser(LayerWithInputParser):
    method __init__ (line 1191) | def __init__(self):
    method parse (line 1194) | def parse(self, name, mcp, prev_layers, model):
  class ConcatentionLayerParser (line 1200) | class ConcatentionLayerParser(LayerWithInputParser):
    method __init__ (line 1201) | def __init__(self):
    method parse (line 1204) | def parse(self, name, mcp, prev_layers, model):
  class PassThroughLayerParser (line 1211) | class PassThroughLayerParser(LayerWithInputParser):
    method __init__ (line 1212) | def __init__(self):
    method parse (line 1218) | def parse(self, name, mcp, prev_layers, model):
  class PoolLayerParser (line 1233) | class PoolLayerParser(LayerWithInputParser):
    method __init__ (line 1234) | def __init__(self):
    method add_params (line 1237) | def add_params(self, mcp):
    method parse (line 1241) | def parse(self, name, mcp, prev_layers, model):
  class CrossMapPoolLayerParser (line 1279) | class CrossMapPoolLayerParser(LayerWithInputParser):
    method __init__ (line 1280) | def __init__(self):
    method parse (line 1283) | def parse(self, name, mcp, prev_layers, model):
  class NormLayerParser (line 1318) | class NormLayerParser(LayerWithInputParser):
    method __init__ (line 1323) | def __init__(self, norm_type):
    method add_params (line 1327) | def add_params(self, mcp):
    method parse (line 1335) | def parse(self, name, mcp, prev_layers, model):
  class CostParser (line 1365) | class CostParser(LayerWithInputParser):
    method __init__ (line 1366) | def __init__(self, num_inputs=-1):
    method parse (line 1369) | def parse(self, name, mcp, prev_layers, model):
    method add_params (line 1386) | def add_params(self, mcp):
  class CrossEntCostParser (line 1392) | class CrossEntCostParser(CostParser):
    method __init__ (line 1393) | def __init__(self):
    method parse (line 1396) | def parse(self, name, mcp, prev_layers, model):
  class LogregCostParser (line 1409) | class LogregCostParser(CostParser):
    method __init__ (line 1410) | def __init__(self):
    method add_params (line 1413) | def add_params(self, mcp):
    method parse (line 1420) | def parse(self, name, mcp, prev_layers, model):
  class BinomialCrossEntCostParser (line 1434) | class BinomialCrossEntCostParser(CostParser):
    method __init__ (line 1435) | def __init__(self):
    method add_params (line 1438) | def add_params(self, mcp):
    method parse (line 1442) | def parse(self, name, mcp, prev_layers, model):
  class DetectionCrossEntCostParser (line 1458) | class DetectionCrossEntCostParser(BinomialCrossEntCostParser):
    method __init__ (line 1459) | def __init__(self):
    method parse (line 1462) | def parse(self, name, mcp, prev_layers, model):
  class SumOfSquaresCostParser (line 1472) | class SumOfSquaresCostParser(CostParser):
    method __init__ (line 1473) | def __init__(self):
    method parse (line 1476) | def parse(self, name, mcp, prev_layers, model):

FILE: caffe2/contrib/cuda-convnet2/make-data/make-data.py
  function pickle (line 50) | def pickle(filename, data):
  function unpickle (line 54) | def unpickle(filename):
  function partition_list (line 60) | def partition_list(l, partition_size):
  function open_tar (line 64) | def open_tar(path, name):
  function makedir (line 70) | def makedir(path):
  function parse_devkit_meta (line 74) | def parse_devkit_meta(ILSVRC_DEVKIT_TAR):
  function write_batches (line 87) | def write_batches(target_dir, name, start_batch_num, labels, jpeg_files):

FILE: caffe2/contrib/cuda-convnet2/make-data/pyext/include/pyext.h
  function class (line 37) | class DecoderThread : public Thread {

FILE: caffe2/contrib/cuda-convnet2/make-data/pyext/src/pyext.cpp
  function init_MakeDataPyExt (line 25) | void init_MakeDataPyExt() {
  function PyObject (line 29) | PyObject* resizeJPEG(PyObject *self, PyObject *args) {
  function PyObject (line 83) | PyObject* DecoderThread::getTargetList() {

FILE: caffe2/contrib/cuda-convnet2/python_util/data.py
  class DataLoaderThread (line 23) | class DataLoaderThread(Thread):
    method __init__ (line 24) | def __init__(self, path, tgt):
    method run (line 28) | def run(self):
  class DataProvider (line 31) | class DataProvider:
    method __init__ (line 33) | def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batc...
    method get_next_batch (line 49) | def get_next_batch(self):
    method get_batch (line 57) | def get_batch(self, batch_num):
    method get_data_dims (line 73) | def get_data_dims(self,idx=0):
    method advance_batch (line 76) | def advance_batch(self):
    method get_next_batch_idx (line 82) | def get_next_batch_idx(self):
    method get_next_batch_num (line 85) | def get_next_batch_num(self):
    method get_data_file_name (line 89) | def get_data_file_name(self, batchnum=None):
    method get_instance (line 95) | def get_instance(cls, data_dir, batch_range=None, init_epoch=1, init_b...
    method register_data_provider (line 113) | def register_data_provider(cls, name, desc, _class):
    method get_batch_meta (line 120) | def get_batch_meta(data_dir):
    method get_batch_filenames (line 124) | def get_batch_filenames(srcdir):
    method get_batch_nums (line 128) | def get_batch_nums(srcdir):
    method get_num_batches (line 133) | def get_num_batches(srcdir):
  class DummyDataProvider (line 136) | class DummyDataProvider(DataProvider):
    method __init__ (line 137) | def __init__(self, data_dim):
    method get_next_batch (line 145) | def get_next_batch(self):
  class LabeledDataProvider (line 151) | class LabeledDataProvider(DataProvider):
    method __init__ (line 152) | def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batc...
    method get_num_classes (line 155) | def get_num_classes(self):
  class LabeledDummyDataProvider (line 158) | class LabeledDummyDataProvider(DummyDataProvider):
    method __init__ (line 159) | def __init__(self, data_dim, num_classes=10, num_cases=7):
    method get_num_classes (line 172) | def get_num_classes(self):
    method get_next_batch (line 175) | def get_next_batch(self):
  class DataProviderException (line 193) | class DataProviderException(Exception):

FILE: caffe2/contrib/cuda-convnet2/python_util/gpumodel.py
  class ModelStateException (line 30) | class ModelStateException(Exception):
  class CheckpointWriter (line 33) | class CheckpointWriter(Thread):
    method __init__ (line 34) | def __init__(self, path, dic):
    method run (line 39) | def run(self):
  class IGPUModel (line 53) | class IGPUModel:
    method __init__ (line 54) | def __init__(self, model_name, op, load_dic, filename_options=[], dp_p...
    method import_model (line 102) | def import_model(self):
    method fill_excused_options (line 107) | def fill_excused_options(self):
    method init_data_providers (line 110) | def init_data_providers(self):
    method init_model_state (line 123) | def init_model_state(self):
    method init_model_lib (line 126) | def init_model_lib(self):
    method start (line 129) | def start(self):
    method train (line 140) | def train(self):
    method cleanup (line 176) | def cleanup(self):
    method print_model_state (line 181) | def print_model_state(self):
    method get_num_batches_done (line 184) | def get_num_batches_done(self):
    method get_next_batch (line 187) | def get_next_batch(self, train=True):
    method parse_batch_data (line 193) | def parse_batch_data(self, batch_data, train=True):
    method start_batch (line 196) | def start_batch(self, batch_data, train=True):
    method finish_batch (line 199) | def finish_batch(self):
    method print_iteration (line 202) | def print_iteration(self):
    method print_elapsed_time (line 205) | def print_elapsed_time(self, compute_time_py):
    method print_train_results (line 208) | def print_train_results(self):
    method print_test_results (line 216) | def print_test_results(self):
    method print_test_status (line 220) | def print_test_status(self):
    method sync_with_host (line 224) | def sync_with_host(self):
    method conditional_save (line 230) | def conditional_save(self):
    method aggregate_test_outputs (line 237) | def aggregate_test_outputs(self, test_outputs):
    method get_test_error (line 241) | def get_test_error(self):
    method set_var (line 261) | def set_var(self, var_name, var_val):
    method get_var (line 266) | def get_var(self, var_name):
    method has_var (line 269) | def has_var(self, var_name):
    method save_state (line 272) | def save_state(self):
    method get_progress (line 293) | def get_progress(self):
    method load_checkpoint (line 298) | def load_checkpoint(load_dir):
    method get_options_parser (line 304) | def get_options_parser():
    method print_data_providers (line 324) | def print_data_providers():
    method parse_options (line 331) | def parse_options(op):

FILE: caffe2/contrib/cuda-convnet2/python_util/options.py
  class Option (line 24) | class Option:
    method __init__ (line 25) | def __init__(self, letter, name, desc, parser, set_once, default, excu...
    method set_value (line 41) | def set_value(self, value, parse=True):
    method set_default (line 49) | def set_default(self):
    method eval_expr_default (line 53) | def eval_expr_default(self, env):
    method get_str_value (line 62) | def get_str_value(self, get_default_str=False):
  class OptionsParser (line 70) | class OptionsParser:
    method __init__ (line 78) | def __init__(self):
    method add_option (line 81) | def add_option(self, letter, name, parser, desc, set_once=False, defau...
    method set_value (line 113) | def set_value(self, name, value, parse=True):
    method get_value (line 116) | def get_value(self, name):
    method delete_option (line 119) | def delete_option(self, name):
    method parse (line 123) | def parse(self, eval_expr_defaults=False):
    method merge_from (line 151) | def merge_from(self, op2):
    method eval_expr_defaults (line 163) | def eval_expr_defaults(self):
    method all_values_given (line 168) | def all_values_given(self):
    method get_options_list (line 171) | def get_options_list(self, sort_order=SORT_LETTER):
    method print_usage (line 182) | def print_usage(self, print_constraints=False):
    method print_values (line 220) | def print_values(self):
    method _longest_value (line 228) | def _longest_value(values, key=lambda x:x):
    method _bold (line 233) | def _bold(str):
  class OptionException (line 236) | class OptionException(Exception):
  class OptionMissingException (line 239) | class OptionMissingException(OptionException):
  class OptionParser (line 242) | class OptionParser:
    method parse (line 244) | def parse(value):
    method to_string (line 248) | def to_string(value):
    method get_type_str (line 252) | def get_type_str():
  class IntegerOptionParser (line 255) | class IntegerOptionParser(OptionParser):
    method parse (line 257) | def parse(value):
    method get_type_str (line 264) | def get_type_str():
    method is_type (line 268) | def is_type(value):
  class BooleanOptionParser (line 271) | class BooleanOptionParser(OptionParser):
    method parse (line 273) | def parse(value):
    method get_type_str (line 283) | def get_type_str():
    method is_type (line 287) | def is_type(value):
  class StringOptionParser (line 290) | class StringOptionParser(OptionParser):
    method get_type_str (line 292) | def get_type_str():
    method is_type (line 296) | def is_type(value):
  class FloatOptionParser (line 299) | class FloatOptionParser(OptionParser):
    method parse (line 301) | def parse(value):
    method to_string (line 308) | def to_string(value):
    method get_type_str (line 312) | def get_type_str():
    method is_type (line 316) | def is_type(value):
  class RangeOptionParser (line 319) | class RangeOptionParser(OptionParser):
    method parse (line 321) | def parse(value):
    method to_string (line 330) | def to_string(value):
    method get_type_str (line 334) | def get_type_str():
    method is_type (line 338) | def is_type(value):
  class ListOptionParser (line 341) | class ListOptionParser(OptionParser):
    method __init__ (line 360) | def __init__(self, parsers, sepchar=','):
    method parse (line 364) | def parse(self, value):
    method to_string (line 376) | def to_string(self, value):
    method get_type_str (line 381) | def get_type_str(self):
    method is_type (line 387) | def is_type(value):
  class OptionExpression (line 390) | class OptionExpression:
    method __init__ (line 400) | def __init__(self, expr):
    method evaluate (line 403) | def evaluate(self, options):

FILE: caffe2/contrib/cuda-convnet2/python_util/util.py
  class UnpickleError (line 20) | class UnpickleError(Exception):
  function pickle (line 26) | def pickle(filename, data):
  function unpickle (line 34) | def unpickle(filename):
  function is_intel_machine (line 50) | def is_intel_machine():
  function get_cpus_for_gpu (line 62) | def get_cpus_for_gpu(gpu):
  function get_cpu (line 79) | def get_cpu():
  function is_windows_machine (line 84) | def is_windows_machine():
  function tryint (line 87) | def tryint(s):
  function alphanum_key (line 93) | def alphanum_key(s):

FILE: caffe2/contrib/cuda-convnet2/shownet.py
  class ShowNetError (line 31) | class ShowNetError(Exception):
  class ShowConvNet (line 34) | class ShowConvNet(ConvNet):
    method __init__ (line 35) | def __init__(self, op, load_dic):
    method init_data_providers (line 38) | def init_data_providers(self):
    method import_model (line 48) | def import_model(self):
    method init_model_state (line 52) | def init_model_state(self):
    method init_model_lib (line 56) | def init_model_lib(self):
    method plot_cost (line 60) | def plot_cost(self):
    method make_filter_fig (line 92) | def make_filter_fig(self, filters, filter_start, fignum, _title, num_f...
    method plot_filters (line 132) | def plot_filters(self):
    method plot_predictions (line 181) | def plot_predictions(self):
    method start (line 294) | def start(self):
    method get_options_parser (line 309) | def get_options_parser(cls):

FILE: caffe2/contrib/cuda-convnet2/util/include/matrix.h
  type int64 (line 49) | typedef long long int int64;
  type FUNCTION (line 81) | enum FUNCTION {
  function MTYPE (line 95) | inline MTYPE& getCell(int64 i, int64 j) const {
  function MTYPE (line 108) | inline MTYPE* getData() const {
  function int64 (line 124) | inline int64 getNumDataBytes() const {
  function isSameDims (line 144) | inline bool isSameDims(const Matrix& a) const {
  function setTrans (line 158) | inline void setTrans(bool trans) {

FILE: caffe2/contrib/cuda-convnet2/util/include/matrix_funcs.h
  function MTYPE (line 32) | inline MTYPE _zero(MTYPE x) {
  function MTYPE (line 36) | inline MTYPE _one(MTYPE x) {
  function MTYPE (line 40) | inline MTYPE _abs(MTYPE x) {
  function MTYPE (line 44) | inline MTYPE _square(MTYPE x) {
  function MTYPE (line 48) | inline MTYPE _sigma1(MTYPE x) {
  function MTYPE (line 52) | inline MTYPE _sigma2(MTYPE x) {
  function MTYPE (line 56) | inline MTYPE _recip(MTYPE x) {
  function MTYPE (line 60) | inline MTYPE _exp(MTYPE x) {
  function MTYPE (line 64) | inline MTYPE _log(MTYPE x) {
  function MTYPE (line 68) | inline MTYPE _tanh(MTYPE x) {
  function MTYPE (line 72) | inline MTYPE _sign(MTYPE x) {
  function MTYPE (line 76) | inline MTYPE _rand(MTYPE x) {
  function MTYPE (line 80) | inline MTYPE _divide(MTYPE x, MTYPE y) {
  function MTYPE (line 84) | inline MTYPE _mult(MTYPE x, MTYPE y) {
  function MTYPE (line 88) | inline MTYPE _add(MTYPE x, MTYPE y) {
  function MTYPE (line 92) | inline MTYPE _addSquare(MTYPE x, MTYPE y) {
  function MTYPE (line 96) | inline MTYPE _addWithScale(MTYPE x, MTYPE y, MTYPE scale) {
  function MTYPE (line 100) | inline MTYPE _addWithScale2(MTYPE x, MTYPE y, MTYPE scaleThis, MTYPE sca...
  function MTYPE (line 104) | inline MTYPE _max(MTYPE x, MTYPE y) {
  function MTYPE (line 108) | inline MTYPE _min(MTYPE x, MTYPE y) {
  function MTYPE (line 112) | inline MTYPE _bigger(MTYPE x, MTYPE y) {
  function MTYPE (line 116) | inline MTYPE _smaller(MTYPE x, MTYPE y) {
  function MTYPE (line 120) | inline MTYPE _equal(MTYPE x, MTYPE y) {
  function MTYPE (line 124) | inline MTYPE _notEqual(MTYPE x, MTYPE y) {

FILE: caffe2/contrib/cuda-convnet2/util/include/queue.h
  function _init (line 35) | void _init(int initialSize) {
  function expand (line 47) | void expand() {
  function enqueue (line 74) | void enqueue(T el) {
  function T (line 90) | T dequeue() {

FILE: caffe2/contrib/cuda-convnet2/util/include/sync.h
  function class (line 22) | class Lock {
  function class (line 42) | class ThreadSynchronizer {
  function sync (line 65) | void sync() {

FILE: caffe2/contrib/cuda-convnet2/util/include/thread.h
  function class (line 31) | class Thread {
  function virtual (line 55) | virtual ~Thread() {
  function setAffinity (line 62) | void setAffinity(std::vector<int>& cpus) {
  function pthread_t (line 77) | pthread_t start() {
  function join (line 89) | void join(void **status) {
  function join (line 98) | void join() {

FILE: caffe2/contrib/cuda-convnet2/util/src/matrix.cpp
  function sqrt (line 21) | double sqrt(int _X) {return sqrt((double) _X);}
  function log (line 22) | double log(int _X) {return log((double) _X);}
  function Matrix (line 107) | Matrix& Matrix::slice(int64 startRow, int64 endRow, int64 startCol, int6...
  function Matrix (line 130) | Matrix& Matrix::sliceRows(int64 startRow, int64 endRow) const {
  function Matrix (line 138) | Matrix& Matrix::sliceCols(int64 startCol, int64 endCol) const {
  function Matrix (line 422) | Matrix& Matrix::transpose() const {
  function Matrix (line 426) | Matrix& Matrix::transpose(bool hard) const {
  function Matrix (line 439) | Matrix& Matrix::tile(int64 timesY, int64 timesX) const {
  function Matrix (line 522) | Matrix& Matrix::copy() const {
  function MTYPE (line 544) | MTYPE Matrix::min() const {
  function Matrix (line 548) | Matrix& Matrix::min(int64 axis) const {
  function MTYPE (line 558) | MTYPE Matrix::max() const {
  function Matrix (line 562) | Matrix& Matrix::max(int64 axis) const {
  function MTYPE (line 572) | MTYPE Matrix::sum() const {
  function MTYPE (line 576) | MTYPE Matrix::norm() const {
  function MTYPE (line 580) | MTYPE Matrix::norm2() const {
  function Matrix (line 584) | Matrix& Matrix::sum(int64 axis) const {
  function MTYPE (line 608) | MTYPE Matrix::_aggregateRow(int64 row, MTYPE (*agg_func)(MTYPE, MTYPE), ...
  function MTYPE (line 616) | MTYPE Matrix::_aggregateCol(int64 col, MTYPE (*agg_func)(MTYPE, MTYPE), ...
  function MTYPE (line 624) | MTYPE Matrix::_aggregate(MTYPE (*agg_func)(MTYPE, MTYPE), MTYPE initialV...
  function Matrix (line 750) | Matrix& Matrix::reshaped(int64 numRows, int64 numCols) {

FILE: caffe2/contrib/gloo/allgather_ops.cc
  type caffe2 (line 21) | namespace caffe2 {
    type gloo (line 22) | namespace gloo {

FILE: caffe2/contrib/gloo/allgather_ops.h
  function namespace (line 29) | namespace caffe2 {

FILE: caffe2/contrib/gloo/allreduce_ops.cc
  type caffe2 (line 24) | namespace caffe2 {
    type gloo (line 25) | namespace gloo {

FILE: caffe2/contrib/gloo/allreduce_ops.h
  function namespace (line 29) | namespace caffe2 {

FILE: caffe2/contrib/gloo/allreduce_ops_gpu.cc
  type caffe2 (line 27) | namespace caffe2 {
    type gloo (line 28) | namespace gloo {
      function initializeAlgorithm (line 34) | std::unique_ptr<::gloo::Algorithm> initializeAlgorithm(

FILE: caffe2/contrib/gloo/barrier_ops.cc
  type caffe2 (line 19) | namespace caffe2 {
    type gloo (line 20) | namespace gloo {

FILE: caffe2/contrib/gloo/barrier_ops.h
  function namespace (line 27) | namespace caffe2 {

FILE: caffe2/contrib/gloo/broadcast_ops.cc
  type caffe2 (line 21) | namespace caffe2 {
    type gloo (line 22) | namespace gloo {

FILE: caffe2/contrib/gloo/broadcast_ops.h
  function namespace (line 29) | namespace caffe2 {

FILE: caffe2/contrib/gloo/broadcast_ops_gpu.cc
  type caffe2 (line 23) | namespace caffe2 {
    type gloo (line 24) | namespace gloo {

FILE: caffe2/contrib/gloo/common.cc
  type caffe2 (line 27) | namespace caffe2 {
    type gloo (line 28) | namespace gloo {
      function signalFailure (line 30) | void signalFailure(Blob* status_blob, std::exception& /* unused */) {
      function createDevice (line 36) | std::shared_ptr<::gloo::transport::Device> createDevice(

FILE: caffe2/contrib/gloo/common.h
  function namespace (line 27) | namespace caffe2 {
  function other (line 82) | bool operator==(GlooParameters const& other) const {

FILE: caffe2/contrib/gloo/common_world_ops.cc
  type caffe2 (line 21) | namespace caffe2 {
    type gloo (line 22) | namespace gloo {

FILE: caffe2/contrib/gloo/common_world_ops.h
  function namespace (line 33) | namespace caffe2 {
  function RunOnDevice (line 246) | bool RunOnDevice() override {

FILE: caffe2/contrib/gloo/common_world_ops_gpu.cc
  type caffe2 (line 24) | namespace caffe2 {
    type gloo (line 25) | namespace gloo {

FILE: caffe2/contrib/gloo/context.cc
  type caffe2 (line 23) | namespace caffe2 {

FILE: caffe2/contrib/gloo/gloo_test.py
  class TemporaryDirectory (line 46) | class TemporaryDirectory:
    method __enter__ (line 47) | def __enter__(self):
    method __exit__ (line 51) | def __exit__(self, type, value, traceback):
  class TestCase (line 55) | class TestCase(hu.HypothesisTestCase):
    method run_test_locally (line 59) | def run_test_locally(self, fn, device_option=None, **kwargs):
    method run_test_distributed (line 101) | def run_test_distributed(self, fn, device_option=None, **kwargs):
    method create_common_world (line 112) | def create_common_world(self, comm_rank, comm_size, tmpdir=None, exist...
    method synchronize (line 153) | def synchronize(self, store_handler, value, comm_rank=None):
    method _test_broadcast (line 171) | def _test_broadcast(self,
    method test_broadcast (line 229) | def test_broadcast(self, comm_size, blob_size, num_blobs, device_option,
    method _test_allreduce (line 250) | def _test_allreduce(self,
    method _test_allreduce_multicw (line 300) | def _test_allreduce_multicw(self,
    method test_allreduce (line 344) | def test_allreduce(self, comm_size, blob_size, num_blobs, device_option,
    method _test_reduce_scatter (line 365) | def _test_reduce_scatter(self,
    method test_reduce_scatter (line 432) | def test_reduce_scatter(self, comm_size, blob_size, num_blobs,
    method _test_allgather (line 453) | def _test_allgather(self,
    method test_allgather (line 512) | def test_allgather(self, comm_size, blob_size, num_blobs, device_option,
    method test_forked_cw (line 534) | def test_forked_cw(self, device_option):
    method _test_barrier (line 548) | def _test_barrier(
    method test_barrier (line 574) | def test_barrier(self, comm_size, device_option):
    method _test_close_connection (line 588) | def _test_close_connection(
    method test_close_connection (line 624) | def test_close_connection(self, comm_size, device_option):
    method _test_io_error (line 642) | def _test_io_error(
    method test_io_error (line 680) | def test_io_error(self, comm_size, device_option):

FILE: caffe2/contrib/gloo/py_export.cc
  type gloo (line 4) | namespace gloo {
    type python (line 5) | namespace python {
      function PYBIND11_MODULE (line 9) | PYBIND11_MODULE(python, m) {

FILE: caffe2/contrib/gloo/reduce_scatter_ops.cc
  type caffe2 (line 22) | namespace caffe2 {
    type gloo (line 23) | namespace gloo {

FILE: caffe2/contrib/gloo/reduce_scatter_ops.h
  function namespace (line 29) | namespace caffe2 {

FILE: caffe2/contrib/gloo/store_handler.cc
  type caffe2 (line 19) | namespace caffe2 {
    type gloo (line 20) | namespace gloo {

FILE: caffe2/contrib/gloo/store_handler.h
  function namespace (line 23) | namespace caffe2 {

FILE: caffe2/contrib/nccl/cuda_nccl_gpu.cc
  type caffe2 (line 19) | namespace caffe2 {
    type nccl (line 21) | namespace nccl {
      function getDevices (line 25) | std::vector<int> getDevices(const NCCLExecution& ex) {
      class NCCLContext (line 34) | class NCCLContext {
        method NCCLContext (line 36) | explicit NCCLContext(const NCCLExecution& ex)
      function ncclKey (line 95) | std::string ncclKey(const NCCLExecution& ex) {
      function NCCLContext (line 106) | NCCLContext* getNCCLContext(const NCCLExecution& ex) {
        method NCCLContext (line 36) | explicit NCCLContext(const NCCLExecution& ex)
      class ncclTypeWrapper (line 117) | class ncclTypeWrapper
      class ncclTypeWrapper<float> (line 120) | class ncclTypeWrapper<float> {
      class ncclTypeWrapper<int> (line 126) | class ncclTypeWrapper<int> {
      class ncclTypeWrapper<float16> (line 133) | class ncclTypeWrapper<float16> {
      function runNCCL (line 140) | void runNCCL(const NCCLExecution& ex, InitF&& init_f, F&& f) {
      class NCCL<float> (line 331) | class NCCL<float>
      class NCCL<int> (line 332) | class NCCL<int>
      class NCCL<float16> (line 334) | class NCCL<float16>

FILE: caffe2/contrib/nccl/cuda_nccl_gpu.h
  function namespace (line 33) | namespace caffe2 {

FILE: caffe2/contrib/nccl/cuda_nccl_op_gpu.cc
  type caffe2 (line 22) | namespace caffe2 {
    function getNCCLElements (line 24) | nccl::NCCLExecution getNCCLElements(
    function AllInputsAre (line 55) | bool AllInputsAre(OperatorBase* op) {
    class NCCLAllreduceOp (line 67) | class NCCLAllreduceOp final : public Operator<CUDAContext> {
      method NCCLAllreduceOp (line 70) | NCCLAllreduceOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDevice (line 72) | bool RunOnDevice() override {
    class NCCLBroadcastOp (line 90) | class NCCLBroadcastOp final : public Operator<CUDAContext> {
      method RunOnDevice (line 94) | bool RunOnDevice() override {
    class NCCLReduceOp (line 111) | class NCCLReduceOp final : public Operator<CUDAContext> {
      method RunOnDevice (line 115) | bool RunOnDevice() override {
    class NCCLAllGatherOp (line 134) | class NCCLAllGatherOp final : public Operator<CUDAContext> {
      method RunOnDevice (line 138) | bool RunOnDevice() override {
    class NCCLReduceScatterOp (line 155) | class NCCLReduceScatterOp final : public Operator<CUDAContext> {
      method RunOnDevice (line 159) | bool RunOnDevice() override {
    function ncclOpDevInfer (line 176) | std::pair<std::vector<DeviceOption>, std::vector<DeviceOption>> ncclOp...

FILE: caffe2/contrib/nccl/nccl_ops_test.py
  function gpu_device (line 36) | def gpu_device(i):
  function benchmark (line 43) | def benchmark(ws, net, warmups=5, iters=100):
  class NCCLOpsTest (line 57) | class NCCLOpsTest(hu.HypothesisTestCase):
    method test_nccl_allreduce (line 61) | def test_nccl_allreduce(self, n, m, in_place):
    method test_nccl_broadcast (line 85) | def test_nccl_broadcast(self, n, m, root):
    method test_nccl_reduce (line 105) | def test_nccl_reduce(self, n, m, root, in_place):
    method test_nccl_allgather (line 124) | def test_nccl_allgather(self, n, m):
    method test_nccl_reduce_scatter (line 144) | def test_nccl_reduce_scatter(self, n, m):
    method _test_nccl_sync (line 166) | def _test_nccl_sync(self, n, m, iters, net_type):
    method test_timings (line 187) | def test_timings(self):

FILE: caffe2/contrib/nervana/nervana.h
  function namespace (line 30) | namespace caffe2 {

FILE: caffe2/contrib/nervana/nervana_fc_op_gpu.cc
  type caffe2 (line 22) | namespace caffe2 {

FILE: caffe2/contrib/nervana/nervana_fc_op_gpu_test.cc
  type caffe2 (line 32) | namespace caffe2 {
    function AddConstInput (line 35) | static void AddConstInput(const std::vector<int>& shape, const float v...
    function TEST (line 50) | TEST(NervanaFullyConnectedTest, Test) {

FILE: caffe2/contrib/nervana/nervana_init_gpu.cc
  type caffe2 (line 28) | namespace caffe2 {
    function NervanaKernelLoaded (line 34) | bool NervanaKernelLoaded() { return g_nervana_kernel_loaded; }
    function Caffe2InitializeNervanaKernels (line 36) | bool Caffe2InitializeNervanaKernels(int*, char***) {

FILE: caffe2/contrib/nervana/nervana_math_gpu.cc
  type caffe2 (line 22) | namespace caffe2 {
    type math (line 24) | namespace math {

FILE: caffe2/contrib/nnpack/nnpack_ops.cc
  type caffe2 (line 40) | namespace caffe2 {
    function has_nnpack (line 47) | bool has_nnpack() {
    function nnp_convolution_algorithm (line 54) | nnp_convolution_algorithm get_nnp_convolution_algorithm(
    function nnp_convolution_transform_strategy (line 71) | nnp_convolution_transform_strategy get_nnp_convolution_transform_strat...
    function pthreadpool_t (line 88) | pthreadpool_t nnpack_threadpool() {
    class NNPACKConvOp (line 112) | class NNPACKConvOp final : public ConvPoolOpBase<CPUContext> {
      method NNPACKConvOp (line 114) | NNPACKConvOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDeviceWithOrderNCHW (line 132) | bool RunOnDeviceWithOrderNCHW() override {
    class NNPACKMaxPoolOp (line 232) | class NNPACKMaxPoolOp final : public ConvPoolOpBase<CPUContext> {
      method NNPACKMaxPoolOp (line 234) | NNPACKMaxPoolOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDeviceWithOrderNCHW (line 265) | bool RunOnDeviceWithOrderNCHW() override {
    class NNPACKReluOp (line 309) | class NNPACKReluOp final : public Operator<CPUContext> {
      method NNPACKReluOp (line 311) | NNPACKReluOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDevice (line 318) | bool RunOnDevice() override {
    class NNPACKLeakyReluOp (line 335) | class NNPACKLeakyReluOp final : public LeakyReluOp<float, CPUContext> {
      method NNPACKLeakyReluOp (line 337) | NNPACKLeakyReluOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDevice (line 344) | bool RunOnDevice() override {

FILE: caffe2/contrib/nnpack/nnpack_ops_test.py
  function benchmark (line 36) | def benchmark(ws, net, warmups=5, iters=100):
  function has_avx2 (line 49) | def has_avx2():
  class NNPackOpsTest (line 60) | class NNPackOpsTest(hu.HypothesisTestCase):
    method test_convolution_correctness (line 69) | def test_convolution_correctness(self, stride, pad, kernel, size,
    method test_max_pool_correctness (line 114) | def test_max_pool_correctness(self, size, input_channels, batch_size):
    method test_relu_correctness (line 147) | def test_relu_correctness(self, size, input_channels, batch_size):
    method test_leaky_relu_correctness (line 171) | def test_leaky_relu_correctness(self, size, input_channels, batch_size,
    method test_timings (line 202) | def test_timings(self, stride, pad, kernel, size,
    method test_relu_timings (line 236) | def test_relu_timings(self, size, input_channels, batch_size):

FILE: caffe2/contrib/playground/AnyExp.py
  function initOpts (line 27) | def initOpts(opts):
  function initDefaultModuleMap (line 54) | def initDefaultModuleMap():
  function registerModuleMap (line 58) | def registerModuleMap(module_map):
  function aquireDatasets (line 62) | def aquireDatasets(opts):
  function createTrainerClass (line 67) | def createTrainerClass(opts):
  function runShardedTrainLoop (line 71) | def runShardedTrainLoop(opts, myTrainFun):
  function trainFun (line 122) | def trainFun():
  function initialize_params_from_file (line 130) | def initialize_params_from_file(*args, **kwargs):
  class AnyExpTrainer (line 133) | class AnyExpTrainer(object):
    method __init__ (line 135) | def __init__(self, opts):
    method get_input_dataset (line 185) | def get_input_dataset(self, opts):
    method get_model_input_fun (line 189) | def get_model_input_fun(self):
    method init_model (line 193) | def init_model(self):
    method init_metrics (line 196) | def init_metrics(self):
    method getMeterClass (line 205) | def getMeterClass(self, meterName):
    method add_metric (line 208) | def add_metric(self, name, calculator, is_train):
    method extendMetricsOutput (line 215) | def extendMetricsOutput(self):
    method init_plots (line 231) | def init_plots(self):
    method add_plot (line 234) | def add_plot(self, x, x_title, ys, y_title):
    method init_logs (line 244) | def init_logs(self):
    method list_of_epochs (line 247) | def list_of_epochs(self):
    method list_of_epoch_iters (line 253) | def list_of_epoch_iters(self):
    method fun_per_epoch_b4RunNet (line 257) | def fun_per_epoch_b4RunNet(self, epoch):
    method fun_per_epoch_aftRunNet (line 261) | def fun_per_epoch_aftRunNet(self, epoch):
    method checkpoint (line 264) | def checkpoint(self, epoch):
    method gen_checkpoint_path (line 269) | def gen_checkpoint_path(self, is_checkpoint, epoch):
    method fun_per_iter_b4RunNet (line 281) | def fun_per_iter_b4RunNet(self, epoch, epoch_iter):
    method fun_per_iter_aftRunNetB4Test (line 285) | def fun_per_iter_aftRunNetB4Test(self, epoch, epoch_iter):
    method fun_per_iter_aftRunNetAftTest (line 289) | def fun_per_iter_aftRunNetAftTest(self, epoch, epoch_iter):
    method fun_conclude_operator (line 293) | def fun_conclude_operator(self, opts):
    method createMetricsPlotsModelsOutputs (line 296) | def createMetricsPlotsModelsOutputs(self):
    method assembleAllOutputs (line 301) | def assembleAllOutputs(self):
    method gen_input_builder_fun (line 305) | def gen_input_builder_fun(self, model, dataset, is_train):
    method gen_forward_pass_builder_fun (line 309) | def gen_forward_pass_builder_fun(self, model, dataset, is_train):
    method gen_param_update_builder_fun (line 313) | def gen_param_update_builder_fun(self, model, dataset, is_train):
    method gen_optimizer_fun (line 317) | def gen_optimizer_fun(self, model, dataset, is_train):
    method gen_rendezvous_ctx (line 321) | def gen_rendezvous_ctx(self, model, dataset, is_train):
    method planning_output (line 325) | def planning_output(self):
    method prep_data_parallel_models (line 330) | def prep_data_parallel_models(self):
    method prep_a_data_parallel_model (line 336) | def prep_a_data_parallel_model(self, model, dataset, is_train):
    method loadCheckpoint (line 382) | def loadCheckpoint(self):
    method buildModelAndTrain (line 415) | def buildModelAndTrain(self, opts):

FILE: caffe2/contrib/playground/ModuleRegister.py
  function registerModuleMap (line 15) | def registerModuleMap(module_map):
  function constructTrainerClass (line 21) | def constructTrainerClass(myTrainerClass, opts):
  function getModule (line 81) | def getModule(moduleName):
  function getClassFromModule (line 97) | def getClassFromModule(moduleName, className):

FILE: caffe2/contrib/playground/checkpoint.py
  function initialize_params_from_file (line 20) | def initialize_params_from_file(
  function initialize_master_xpu_model_params (line 29) | def initialize_master_xpu_model_params(model, weights_file, opts, reset_...
  function broadcast_parameters (line 99) | def broadcast_parameters(opts, model, num_xpus, broadcast_computed_param...
  function save_model_params (line 124) | def save_model_params(is_checkpoint, model, checkpoint_path, epoch, opts...
  function save_model_params_blob (line 135) | def save_model_params_blob(model, params_file, epoch, opts, best_metric):
  function unscope_name (line 166) | def unscope_name(blob_name):
  function scoped_name (line 170) | def scoped_name(blob_name):

FILE: caffe2/contrib/playground/compute_loss.py
  class ComputeLoss (line 10) | class ComputeLoss(Meter.Meter):
    method __init__ (line 11) | def __init__(self, opts=None, blob_name=''):
    method Reset (line 17) | def Reset(self):
    method Add (line 21) | def Add(self):
    method Compute (line 32) | def Compute(self):

FILE: caffe2/contrib/playground/compute_topk_accuracy.py
  class ComputeTopKAccuracy (line 11) | class ComputeTopKAccuracy(Meter.Meter):
    method __init__ (line 18) | def __init__(self, blob_name=None, opts=None, topk=1):
    method Reset (line 27) | def Reset(self):
    method Add (line 31) | def Add(self):
    method Compute (line 56) | def Compute(self):

FILE: caffe2/contrib/playground/meter.py
  class Meter (line 9) | class Meter(object):
    method __init__ (line 12) | def __init__(self, **kwargs):
    method Reset (line 16) | def Reset(self):
    method Add (line 20) | def Add(self):
    method Compute (line 24) | def Compute(self):

FILE: caffe2/contrib/playground/output_generator.py
  function fun_conclude_operator (line 8) | def fun_conclude_operator(self):
  function assembleAllOutputs (line 14) | def assembleAllOutputs(self):

FILE: caffe2/contrib/playground/resnet50demo/IN1k_resnet50.py
  function init_model (line 13) | def init_model(self):
  function fun_per_epoch_b4RunNet (line 34) | def fun_per_epoch_b4RunNet(self, epoch):
  function fun_per_iter_b4RunNet (line 38) | def fun_per_iter_b4RunNet(self, epoch, epoch_iter):
  function run_training_net (line 54) | def run_training_net(self):

FILE: caffe2/contrib/playground/resnet50demo/caffe2_resnet50_default_forward.py
  function gen_forward_pass_builder_fun (line 9) | def gen_forward_pass_builder_fun(self, model, dataset, is_train):

FILE: caffe2/contrib/playground/resnet50demo/caffe2_resnet50_default_param_update.py
  function gen_param_update_builder_fun (line 7) | def gen_param_update_builder_fun(self, model, dataset, is_train):

FILE: caffe2/contrib/playground/resnet50demo/explicit_resnet_forward.py
  function gen_forward_pass_builder_fun (line 11) | def gen_forward_pass_builder_fun(self, model, dataset, is_train):
  function resnet_imagenet_create_model (line 28) | def resnet_imagenet_create_model(model, data, labels, split, opts, datas...
  class ResNetModelHelper (line 114) | class ResNetModelHelper():
    method __init__ (line 116) | def __init__(self, model, split, opts):
    method add_shortcut (line 122) | def add_shortcut(self, blob_in, dim_in, dim_out, stride, prefix):
    method conv_bn (line 144) | def conv_bn(
    method conv_bn_relu (line 164) | def conv_bn_relu(
    method multiway_bottleneck_block (line 174) | def multiway_bottleneck_block(
    method group_bottleneck_block (line 211) | def group_bottleneck_block(
    method bottleneck_block (line 236) | def bottleneck_block(
    method basic_block (line 260) | def basic_block(
    method residual_layer (line 276) | def residual_layer(

FILE: caffe2/contrib/playground/resnet50demo/explicit_resnet_param_update.py
  function gen_param_update_builder_fun (line 10) | def gen_param_update_builder_fun(self, model, dataset, is_train):

FILE: caffe2/contrib/playground/resnet50demo/gfs_IN1k.py
  function gen_input_builder_fun (line 8) | def gen_input_builder_fun(self, model, dataset, is_train):
  function get_input_dataset (line 49) | def get_input_dataset(opts):
  function get_model_input_fun (line 53) | def get_model_input_fun(self):

FILE: caffe2/contrib/playground/resnet50demo/rendezvous_filestore.py
  function gen_rendezvous_ctx (line 19) | def gen_rendezvous_ctx(self, model, dataset, is_train):

FILE: caffe2/contrib/prof/cuda_profile_ops.cc
  type caffe2 (line 25) | namespace caffe2 {
    class CudaProfileInitializeOp (line 47) | class CudaProfileInitializeOp : public OperatorBase {
      method CudaProfileInitializeOp (line 49) | CudaProfileInitializeOp(const OperatorDef& operator_def, Workspace* ws)
      method Run (line 74) | virtual bool Run(int /* unused */ /*stream_id*/ = 0) {
    class CudaProfileStartOp (line 86) | class CudaProfileStartOp : public OperatorBase {
      method CudaProfileStartOp (line 88) | CudaProfileStartOp(const OperatorDef& operator_def, Workspace* ws)
      method Run (line 91) | virtual bool Run(int /* unused */ /*stream_id*/ = 0) {
    class CudaProfileStopOp (line 97) | class CudaProfileStopOp : public OperatorBase {
      method CudaProfileStopOp (line 99) | CudaProfileStopOp(const OperatorDef& operator_def, Workspace* ws)
      method Run (line 102) | virtual bool Run(int /* unused */ /*stream_id*/ = 0) {

FILE: caffe2/contrib/prof/cuda_profile_ops_test.py
  class CudaProfileOpsTest (line 28) | class CudaProfileOpsTest(unittest.TestCase):
    method test_run (line 30) | def test_run(self):

FILE: caffe2/contrib/prof/htrace_async_dag_net_gpu.cc
  type caffe2 (line 23) | namespace caffe2 {
    class HTraceAsyncDAGNet (line 26) | class HTraceAsyncDAGNet : public AsyncDAGNet {
      method HTraceAsyncDAGNet (line 28) | HTraceAsyncDAGNet(const std::shared_ptr<const NetDef>& net_def, Work...
      method DoRunAsync (line 54) | bool DoRunAsync() override {

FILE: caffe2/contrib/prof/htrace_conf.cc
  type caffe2 (line 28) | namespace caffe2 {
    function string (line 30) | const string defaultHTraceConf(const string& net_name) {

FILE: caffe2/contrib/prof/htrace_conf.h
  function namespace (line 23) | namespace caffe2 {

FILE: caffe2/contrib/prof/htrace_dag_net.cc
  type caffe2 (line 23) | namespace caffe2 {
    class HTraceDAGNet (line 26) | class HTraceDAGNet : public DAGNetBase {
      method HTraceDAGNet (line 28) | HTraceDAGNet(const std::shared_ptr<const NetDef>& net_def, Workspace...
      method SupportsAsync (line 41) | bool SupportsAsync() override {
      method DoRunAsync (line 58) | bool DoRunAsync() override {
      method RunAt (line 66) | bool RunAt(int /* unused */, const std::vector<int>& chain) override {

FILE: caffe2/contrib/prof/htrace_to_chrome.py
  function stop_display (line 31) | def stop_display(limit, curr):
  function build_trace_dict (line 35) | def build_trace_dict(f, start_time, end_time):
  function generate_chrome_trace (line 80) | def generate_chrome_trace(root_list, display):
  function get_argument_parser (line 189) | def get_argument_parser():
  function main (line 203) | def main():

FILE: caffe2/contrib/prof/prof_dag_net.cc
  type caffe2 (line 24) | namespace caffe2 {
    function ProfDAGProto (line 103) | ProfDAGProto ProfDAGNet::ProtoMsg(std::pair<std::string, Stats> op_sta...
    function ProfDAGProtos (line 113) | ProfDAGProtos ProfDAGNet::GetOperatorStats() {
    function ProfDAGProtos (line 124) | ProfDAGProtos ProfDAGNet::GetPerOperatorCost() {

FILE: caffe2/contrib/prof/prof_dag_net.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/contrib/prof/prof_dag_stats_op.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/contrib/script/caffe2_script_test.py
  function feed_inputs (line 16) | def feed_inputs(inputs):
  function assert_proto_equals (line 21) | def assert_proto_equals(proto, expected):
  class TestCaffe2Script (line 31) | class TestCaffe2Script(hu.HypothesisTestCase):
    method test_foo (line 56) | def test_foo(self, firstdim, seconddim, seed, gc, dc):
    method test_trinary (line 76) | def test_trinary(self):
    method test_bool_literal (line 90) | def test_bool_literal(self):
    method test_bool_operators (line 102) | def test_bool_operators(self):
    method expect_fail (line 120) | def expect_fail(self, fn, msg):
    method test_fails (line 129) | def test_fails(self):
    method test_print (line 154) | def test_print(self):
    method test_method (line 170) | def test_method(self):
    method test_plus_eq (line 180) | def test_plus_eq(self):
    method test_cast (line 191) | def test_cast(self):
    method test_global (line 201) | def test_global(self):
    method test_module_as_arg_ret (line 214) | def test_module_as_arg_ret(self):
    method test_call_extern (line 235) | def test_call_extern(self):
    method test_if (line 266) | def test_if(self, seed, gc, dc):
    method test_while (line 289) | def test_while(self, seed, gc, dc):
    method test_gather (line 310) | def test_gather(self, seed, gc, dc):
    method test_slice (line 368) | def test_slice(self, seed, gc, dc):

FILE: caffe2/contrib/script/compiler.cc
  type caffe2 (line 7) | namespace caffe2 {
    type script (line 8) | namespace script {
      type FunctionDefinition (line 19) | struct FunctionDefinition {
        method FunctionDefinition (line 20) | explicit FunctionDefinition(Def tree)
        method FunctionDefinition (line 23) | explicit FunctionDefinition(std::unique_ptr<NetDef> def)
        method isExtern (line 41) | bool isExtern() const {
      type DefCompiler (line 54) | struct DefCompiler {
        method DefCompiler (line 55) | DefCompiler(FunctionDefinition& def, SymbolTable& symbol_table)
        method run (line 59) | void run() {
        method emitExpressionStatement (line 74) | void emitExpressionStatement(TreeRef stmt) {
        method emitStatements (line 78) | void emitStatements(const ListView<TreeRef>& statements) {
        method map (line 102) | void map(const std::string& name, const std::string& value) {
        method emitAssignment (line 110) | void emitAssignment(const Assign& stmt) {
        method emitIf (line 141) | void emitIf(const If& stmt) {
        method emitWhile (line 161) | void emitWhile(const While& stmt) {
        method getLHS (line 183) | std::string getLHS(const TreeRef& tree) {
        method getValue (line 200) | std::string getValue(const TreeRef& tree) {
        method fresh (line 218) | std::string fresh(std::string prefix = "$t") {
        method fillArg (line 258) | void fillArg(Argument* arg, const Attribute& attr) {
        method getValues (line 285) | std::vector<std::string> getValues(const Trees& trees) {
        method renameLookup (line 293) | bool renameLookup(
        method renameOp (line 315) | void renameOp(
        method hasBypassRename (line 358) | bool hasBypassRename(const Apply& apply) {
        method emitFunctionCall (line 376) | void emitFunctionCall(Apply& apply, const std::vector<std::string>...
        method expectOutputs (line 406) | void expectOutputs(
        method appendOutputs (line 416) | void appendOutputs(
        method emitOperator (line 426) | void emitOperator(
        method emit (line 473) | void emit(const TreeRef& tree, const std::vector<std::string>& out...
        method desugarAndEmitOperator (line 573) | void desugarAndEmitOperator(
        method TensorProto_DataType (line 589) | TensorProto_DataType getType(int type) {
        method OperatorDef (line 605) | OperatorDef* emitConst(
        method NetDef (line 636) | NetDef& cur() {
        method emitFillOp (line 647) | void emitFillOp(const Apply& apply, const std::vector<std::string>...
        method emitModule (line 709) | void emitModule(const Apply& apply, const std::vector<std::string>...
      type CompilationUnitImpl (line 725) | struct CompilationUnitImpl {
        method defineFunction (line 726) | void defineFunction(const Def& def) {
        method define (line 737) | void define(const std::string& str) {
        method createNet (line 744) | std::unique_ptr<NetBase> createNet(Workspace* ws, const std::strin...
        method defineExtern (line 751) | void defineExtern(const std::string& name, std::unique_ptr<NetDef>...
        method getProto (line 759) | std::string getProto(const std::string& functionName) {

FILE: caffe2/contrib/script/compiler.h
  function namespace (line 6) | namespace caffe2 {

FILE: caffe2/contrib/script/error_report.h
  function namespace (line 5) | namespace caffe2 {

FILE: caffe2/contrib/script/lexer.cc
  type caffe2 (line 4) | namespace caffe2 {
    type script (line 5) | namespace script {
      function kindToString (line 7) | std::string kindToString(int kind) {
      function SharedParserData (line 21) | SharedParserData& sharedParserData() {

FILE: caffe2/contrib/script/lexer.h
  function namespace (line 13) | namespace caffe2 {
  type SharedParserData (line 115) | struct SharedParserData {
  function isUnary (line 265) | bool isUnary(int kind, int* prec) {
  function isBinary (line 273) | bool isBinary(int kind, int* prec) {
  function isRightAssociative (line 281) | bool isRightAssociative(int kind) {
  type SourceRange (line 306) | struct SourceRange {
  function text (line 354) | struct Token {
  type Lookahead (line 373) | struct Lookahead {
  function next (line 380) | struct Lexer {
  function nextIf (line 407) | bool nextIf(int kind) {
  function reportError (line 414) | [[noreturn]] void reportError(const std::string& what) {
  function reportError (line 417) | [[noreturn]] void reportError(const std::string& what, const Token& t) {
  function expected (line 423) | [[noreturn]] void expected(const std::string& what, const Token& t) {
  function expected (line 430) | [[noreturn]] void expected(const std::string& what) {
  function Token (line 433) | Token expect(int kind) {

FILE: caffe2/contrib/script/parser.h
  function namespace (line 6) | namespace caffe2 {

FILE: caffe2/contrib/script/tree.h
  type Tree (line 27) | struct Tree
  function Tree (line 33) | struct Tree : std::enable_shared_from_this<Tree> {
  function Tree (line 94) | struct String : public Tree {
  function Tree (line 107) | struct Number : public Tree {
  function Tree (line 120) | struct Bool : public Tree {
  function virtual (line 151) | virtual const TreeList& trees() const override {
  function virtual (line 161) | virtual TreeRef map(std::function<TreeRef(TreeRef)> fn) override {

FILE: caffe2/contrib/script/tree_views.h
  function namespace (line 5) | namespace caffe2 {

FILE: caffe2/contrib/shm_mutex/shm_mutex.cc
  function ShmProcessMutexCheck (line 19) | ShmProcessMutexCheck& ShmProcessMutexCheck::getInstance() {

FILE: caffe2/contrib/shm_mutex/shm_mutex.h
  function class (line 59) | class ShmProcessMutexCheck {
  function explicit (line 88) | explicit ShmProcessMutex(const char* name)
  function lock (line 190) | void lock() {
  function try_lock (line 218) | bool try_lock() {
  function unlock (line 241) | void unlock() noexcept {
  function explicit (line 287) | explicit ShmTTSetMutex(const char* name, int timeout = kTimeout)
  function subUnlock (line 303) | void subUnlock() noexcept {}
  function explicit (line 311) | explicit ShmTicketMutex(const char* name, int delay = kTicketDelay)
  function subUnlock (line 333) | void subUnlock() noexcept {

FILE: caffe2/contrib/tensorboard/tensorboard.py
  class Config (line 18) | class Config(object):
  function _show_graph (line 47) | def _show_graph(graph_def):
  function visualize_cnn (line 63) | def visualize_cnn(cnn, **kwargs):
  function visualize_net (line 68) | def visualize_net(nets, **kwargs):
  function visualize_ops (line 73) | def visualize_ops(ops, **kwargs):
  function cli (line 79) | def cli():
  function write_events (line 83) | def write_events(tf_dir, events):
  function graph_def_to_event (line 97) | def graph_def_to_event(step, graph_def):
  function tensorboard_graphs (line 106) | def tensorboard_graphs(c2_netdef, tf_dir):
  function tensorboard_events (line 130) | def tensorboard_events(c2_dir, tf_dir):

FILE: caffe2/contrib/tensorboard/tensorboard_exporter.py
  function _make_unique_name (line 19) | def _make_unique_name(seen, name, min_version=0):
  function _convert_to_ssa (line 30) | def _convert_to_ssa(shapes, track_blob_names, ops):
  function _get_blob_names (line 76) | def _get_blob_names(ops):
  function _remap_keys (line 84) | def _remap_keys(m, f):
  function _rename_all (line 90) | def _rename_all(shapes, track_blob_names, ops, f):
  function _add_gradient_scope (line 124) | def _add_gradient_scope(shapes, track_blob_names, ops):
  function _replace_colons (line 140) | def _replace_colons(shapes, track_blob_names, ops, repl):
  function _fill_missing_operator_names (line 149) | def _fill_missing_operator_names(ops):
  function _tf_device (line 174) | def _tf_device(device_option):
  function _add_tf_shape (line 184) | def _add_tf_shape(m, ints):
  function _set_tf_attr (line 193) | def _set_tf_attr(m, arg):
  function _operator_to_node (line 225) | def _operator_to_node(shapes, op):
  function _blob_to_node (line 244) | def _blob_to_node(producing_ops, shapes, name):
  function _operators_to_graph_def (line 264) | def _operators_to_graph_def(
  function _propagate_device_option (line 298) | def _propagate_device_option(net):
  function _try_get_shapes (line 306) | def _try_get_shapes(nets):
  function nets_to_graph_def (line 316) | def nets_to_graph_def(nets, shapes=None, **kwargs):
  function cnn_to_graph_def (line 330) | def cnn_to_graph_def(cnn, **kwargs):
  function ops_to_graph_def (line 334) | def ops_to_graph_def(ops, shapes=None, **kwargs):

FILE: caffe2/contrib/tensorboard/tensorboard_exporter_test.py
  class TensorboardExporterTest (line 591) | class TensorboardExporterTest(unittest.TestCase):
    method test_that_operators_gets_non_colliding_names (line 592) | def test_that_operators_gets_non_colliding_names(self):
    method test_that_replacing_colons_gives_non_colliding_names (line 600) | def test_that_replacing_colons_gives_non_colliding_names(self):
    method test_that_adding_gradient_scope_does_no_fancy_renaming (line 619) | def test_that_adding_gradient_scope_does_no_fancy_renaming(self):
    method test_that_auto_ssa_gives_non_colliding_names (line 638) | def test_that_auto_ssa_gives_non_colliding_names(self):
    method test_simple_cnnmodel (line 662) | def test_simple_cnnmodel(self):

FILE: caffe2/contrib/tensorboard/tensorboard_test.py
  class TensorboardTest (line 18) | class TensorboardTest(unittest.TestCase):
    method test_events (line 20) | def test_events(self):
    method test_tensorboard_graphs (line 52) | def test_tensorboard_graphs(self):

FILE: caffe2/contrib/torch/th_ops.cc
  type caffe2 (line 24) | namespace caffe2 {
    function UniqueTHFloatTensor (line 31) | UniqueTHFloatTensor aliasFromTensorCPU(TensorCPU* tensor) {
    function copyToTensorCPU (line 51) | void copyToTensorCPU(UniqueTHFloatTensor th, TensorCPU* tensor) {
    class THNNELUCPUOp (line 75) | class THNNELUCPUOp final : public Operator<CPUContext> {
      method RunOnDevice (line 79) | bool RunOnDevice() override {
    class THNNELUCPUGradientOp (line 94) | class THNNELUCPUGradientOp final : public Operator<CPUContext> {
      method RunOnDevice (line 99) | bool RunOnDevice() override {
    class GetELUGradient (line 121) | class GetELUGradient : public GradientMakerBase {
      method GetGradientDefs (line 123) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/contrib/torch/th_ops_test.py
  class THOpsTest (line 41) | class THOpsTest(hu.HypothesisTestCase):
    method test_elu (line 46) | def test_elu(self, X, alpha, in_place, gc, dc):

FILE: caffe2/contrib/torch/torch_op.cpp
  type caffe2 (line 19) | namespace caffe2 {
    type torch (line 21) | namespace torch {
    type GetTorchGradient (line 31) | struct GetTorchGradient : public GradientMakerBase {
      method GetGradientDefs (line 33) | std::vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/contrib/torch/torch_op.h
  function namespace (line 32) | namespace caffe2 {

FILE: caffe2/contrib/torch/torch_op_gpu.cpp
  type caffe2 (line 26) | namespace caffe2 {
    type torch (line 28) | namespace torch {
      type TyTraits<CUDAContext> (line 31) | struct TyTraits<CUDAContext> {
      function THCState (line 46) | THCState* cudaState(Torch<CUDAContext>* t) {

FILE: caffe2/contrib/torch/torch_ops_test.py
  class TorchOpTest (line 49) | class TorchOpTest(hu.HypothesisTestCase):
    method test_feed (line 53) | def test_feed(self, n, i, h):
    method test_gradient (line 77) | def test_gradient(self, n, i, h, gc, dc):
    method test_iterated (line 97) | def test_iterated(self, n, i, h, iters):
    method test_leakage_torch (line 123) | def test_leakage_torch(self):

FILE: caffe2/contrib/warpctc/ctc_op.cpp
  type caffe2 (line 21) | namespace caffe2 {
    type detail (line 23) | namespace detail {
      function ctcComputeInfo (line 25) | ctcComputeInfo workspaceInfo<CPUContext>(const CPUContext& /*context...
    class GetCTCGradient (line 40) | class GetCTCGradient : public GradientMakerBase {
      method GetGradientDefs (line 42) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/contrib/warpctc/ctc_op.h
  function namespace (line 40) | namespace caffe2 {

FILE: caffe2/contrib/warpctc/ctc_op_gpu.cpp
  type caffe2 (line 21) | namespace caffe2 {
    type detail (line 23) | namespace detail {
      function ctcComputeInfo (line 25) | ctcComputeInfo workspaceInfo<CUDAContext>(const CUDAContext& context) {

FILE: caffe2/contrib/warpctc/ctc_ops_test.py
  function softmax (line 29) | def softmax(w):
  class CTCOpsTest (line 36) | class CTCOpsTest(test_util.TestCase):
    method verify_cost (line 37) | def verify_cost(self, device_option, is_test):
    method test_ctc_cost_cpu (line 82) | def test_ctc_cost_cpu(self):
    method test_ctc_cost_gpu (line 87) | def test_ctc_cost_gpu(self):
    method test_ctc_forward_only_cpu (line 93) | def test_ctc_forward_only_cpu(self):
    method test_ctc_forward_only_gpu (line 98) | def test_ctc_forward_only_gpu(self):

FILE: caffe2/core/allocator.cc
  type caffe2 (line 32) | namespace caffe2 {
    function NoDelete (line 34) | void NoDelete(void*) {}
    function CPUAllocator (line 37) | CPUAllocator* GetCPUAllocator() {
    function SetCPUAllocator (line 41) | void SetCPUAllocator(CPUAllocator* alloc) {

FILE: caffe2/core/allocator.h
  function namespace (line 28) | namespace caffe2 {

FILE: caffe2/core/blob.h
  function namespace (line 32) | namespace caffe2 {

FILE: caffe2/core/blob_gpu_test.cc
  type caffe2 (line 25) | namespace caffe2 {
    class TensorGPUTest (line 28) | class TensorGPUTest : public ::testing::Test {}
    class TensorGPUDeathTest (line 29) | class TensorGPUDeathTest : public ::testing::Test {}
    function TYPED_TEST (line 34) | TYPED_TEST(TensorGPUTest, TensorInitializedEmpty) {
    function TYPED_TEST (line 51) | TYPED_TEST(TensorGPUTest, TensorInitializedNonEmpty) {
    function TYPED_TEST (line 78) | TYPED_TEST(TensorGPUTest, TensorShareData) {
    function TYPED_TEST (line 93) | TYPED_TEST(TensorGPUTest, TensorShareDataCanUseDifferentShapes) {
    function TYPED_TEST (line 112) | TYPED_TEST(TensorGPUTest, NoLongerSharesAfterResize) {
    function TYPED_TEST (line 131) | TYPED_TEST(TensorGPUDeathTest, CannotAccessDataWhenEmpty) {
    function TEST (line 189) | TEST(TensorTest, TensorSerializationMultiDevices) {

FILE: caffe2/core/blob_serialization.cc
  type caffe2 (line 40) | namespace caffe2 {
    class StringSerializer (line 47) | class StringSerializer : public BlobSerializerBase {
      method StringSerializer (line 49) | StringSerializer() {}
      method Serialize (line 55) | void Serialize(
    class StringDeserializer (line 73) | class StringDeserializer : public BlobDeserializerBase {
      method Deserialize (line 75) | void Deserialize(const BlobProto& proto, Blob* blob) override {

FILE: caffe2/core/blob_serialization.h
  function namespace (line 36) | namespace caffe2 {
  function processChunk (line 223) | auto processChunk = [&](int64_t chunkStart) {

FILE: caffe2/core/blob_serialization_gpu.cc
  type caffe2 (line 21) | namespace caffe2 {

FILE: caffe2/core/blob_serializer_base.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/core/blob_stats.cc
  type caffe2 (line 19) | namespace caffe2 {
    function BlobStatGetter (line 21) | const BlobStatGetter* BlobStatRegistry::get(CaffeTypeId id) {
    function BlobStatRegistry (line 29) | BlobStatRegistry& BlobStatRegistry::instance() {
    type BlobStat (line 44) | namespace BlobStat {
      function sizeBytes (line 46) | size_t sizeBytes(const Blob& blob) {

FILE: caffe2/core/blob_stats.h
  function namespace (line 25) | namespace caffe2 {

FILE: caffe2/core/blob_test.cc
  type caffe2 (line 41) | namespace caffe2 {
    class BlobTestFoo (line 44) | class BlobTestFoo {
    class BlobTestBar (line 48) | class BlobTestBar {}
    class BlobTestFooSerializer (line 54) | class BlobTestFooSerializer : public BlobSerializerBase {
      method BlobTestFooSerializer (line 56) | BlobTestFooSerializer() {}
      method Serialize (line 62) | void Serialize(
    class BlobTestFooDeserializer (line 79) | class BlobTestFooDeserializer : public BlobDeserializerBase {
      method Deserialize (line 81) | void Deserialize(const BlobProto& proto, Blob* blob) override {
    function TEST (line 92) | TEST(BlobTest, Blob) {
    function TEST (line 104) | TEST(BlobTest, BlobNewObjectFlag) {
    function TEST (line 120) | TEST(BlobTest, BlobUninitialized) {
    function TEST (line 125) | TEST(BlobTest, BlobWrongType) {
    function TEST (line 135) | TEST(BlobTest, BlobReset) {
    function TEST (line 143) | TEST(BlobTest, BlobMove) {
    function TEST (line 156) | TEST(BlobTest, BlobShareExternalPointer) {
    function TEST (line 165) | TEST(BlobTest, BlobShareExternalObject) {
    function TEST (line 174) | TEST(BlobTest, StringSerialization) {
    function TEST (line 188) | TEST(TensorNonTypedTest, TensorChangeType) {
    class TensorCPUTest (line 222) | class TensorCPUTest : public ::testing::Test {}
    class TensorCPUDeathTest (line 223) | class TensorCPUDeathTest : public ::testing::Test {}
    function TYPED_TEST (line 228) | TYPED_TEST(TensorCPUTest, TensorInitializedEmpty) {
    function TYPED_TEST (line 245) | TYPED_TEST(TensorCPUTest, TensorInitializedNonEmpty) {
    function TYPED_TEST (line 271) | TYPED_TEST(TensorCPUTest, TensorInitializedZeroDim) {
    function TYPED_TEST (line 285) | TYPED_TEST(TensorCPUTest, TensorResizeZeroDim) {
    function TYPED_TEST (line 312) | TYPED_TEST(TensorCPUTest, TensorInitializedScalar) {
    function TYPED_TEST (line 321) | TYPED_TEST(TensorCPUTest, TensorShareData) {
    function TYPED_TEST (line 340) | TYPED_TEST(TensorCPUTest, TensorShareDataRawPointer) {
    function TYPED_TEST (line 357) | TYPED_TEST(TensorCPUTest, TensorShareDataRawPointerWithMeta) {
    function TYPED_TEST (line 375) | TYPED_TEST(TensorCPUTest, CannotShareDataWhenShapeNotSet) {
    function TYPED_TEST (line 381) | TYPED_TEST(TensorCPUTest, TensorShareDataCanUseDifferentShapes) {
    function TYPED_TEST (line 405) | TYPED_TEST(TensorCPUTest, NoLongerSharesAfterResize) {
    function TYPED_TEST (line 423) | TYPED_TEST(TensorCPUTest, NoLongerSharesAfterFreeMemory) {
    function TYPED_TEST (line 440) | TYPED_TEST(TensorCPUTest, KeepOnShrink) {
    function TYPED_TEST (line 471) | TYPED_TEST(TensorCPUTest, MaxKeepOnShrink) {
    function TYPED_TEST (line 497) | TYPED_TEST(TensorCPUDeathTest, CannotAccessRawDataWhenEmpty) {
    function TYPED_TEST (line 503) | TYPED_TEST(TensorCPUDeathTest, CannotAccessDataWhenEmpty) {
    function TEST (line 509) | TEST(TensorTest, TensorNonFundamentalType) {
    function TEST (line 518) | TEST(TensorTest, TensorNonFundamentalTypeCopy) {
    function TEST (line 533) | TEST(TensorTest, Tensor64BitDimension) {
    function TEST (line 566) | TEST(TensorDeathTest, CannotCastDownLargeDims) {
    function TEST (line 645) | TEST(TensorTest, TensorSerialization_CustomType) {
    function TEST (line 671) | TEST(TensorTest, float16) {
    function TEST (line 711) | TEST(QTensorTest, QTensorSerialization) {
    class VectorCursor (line 756) | class VectorCursor : public db::Cursor {
      method VectorCursor (line 758) | explicit VectorCursor(StringMap* data) : data_(data) {
      method Seek (line 762) | void Seek(const string& /* unused */) override {}
      method SeekToFirst (line 763) | void SeekToFirst() override {}
      method Next (line 764) | void Next() override {
      method string (line 767) | string key() override {
      method string (line 770) | string value() override {
      method Valid (line 773) | bool Valid() override {
    class VectorDB (line 782) | class VectorDB : public db::DB {
      method VectorDB (line 784) | VectorDB(const string& source, db::Mode mode)
      method Close (line 789) | void Close() override {}
      method NewCursor (line 790) | std::unique_ptr<db::Cursor> NewCursor() override {
      method NewTransaction (line 793) | std::unique_ptr<db::Transaction> NewTransaction() override {
      method registerData (line 796) | static void registerData(const string& name, StringMap&& data) {
      method StringMap (line 802) | StringMap* getData() {
    class TypedTensorTest (line 820) | class TypedTensorTest : public ::testing::Test {}
    function TYPED_TEST (line 826) | TYPED_TEST(TypedTensorTest, BigTensorSerialization) {
    type DummyType (line 893) | struct DummyType {
      method DummyType (line 898) | DummyType(int n_chunks_init = 0) : n_chunks(n_chunks_init) {}
      method serialize (line 899) | std::string serialize(const std::string& name, const int32_t chunk_i...
      method deserialize (line 909) | void deserialize(const BlobProto& /* unused */) {
    class DummyTypeSerializer (line 915) | class DummyTypeSerializer : public BlobSerializerBase {
      method DummyTypeSerializer (line 917) | DummyTypeSerializer() {}
      method Serialize (line 919) | void Serialize(
    class DummyTypeDeserializer (line 932) | class DummyTypeDeserializer : public BlobDeserializerBase {
      method Deserialize (line 934) | void Deserialize(const BlobProto& proto, Blob* blob) override {
    function TEST (line 950) | TEST(ContentChunks, Serialization) {
    function TEST (line 1000) | TEST(CustomChunkSize, BigTensorSerialization) {
    function TEST (line 1030) | TEST(QTensor, QTensorSizingTest) {
    function TEST (line 1041) | TEST(BlobTest, CastingMessage) {

FILE: caffe2/core/common.cc
  type caffe2 (line 21) | namespace caffe2 {
    function HasCudaRuntime (line 28) | bool HasCudaRuntime() {
    type internal (line 32) | namespace internal {
      function SetCudaRuntimeFlag (line 33) | void SetCudaRuntimeFlag() {

FILE: caffe2/core/common.h
  function namespace (line 44) | namespace caffe2 {

FILE: caffe2/core/common_cudnn.cc
  type caffe2 (line 22) | namespace caffe2 {
    function PrintCuDNNInfo (line 33) | bool PrintCuDNNInfo(int*, char***) {

FILE: caffe2/core/common_cudnn.h
  function namespace (line 44) | namespace caffe2 {

FILE: caffe2/core/common_gpu.cc
  type caffe2 (line 40) | namespace caffe2 {
    function NumCudaDevices (line 42) | int NumCudaDevices() {
    function SetDefaultGPUID (line 111) | void SetDefaultGPUID(const int deviceid) {
    function GetDefaultGPUID (line 123) | int GetDefaultGPUID() { return gDefaultGPUID; }
    function CaffeCudaGetDevice (line 125) | int CaffeCudaGetDevice() {
    function CaffeCudaSetDevice (line 138) | void CaffeCudaSetDevice(const int id) {
    function GetGPUIDForPointer (line 149) | int GetGPUIDForPointer(const void* ptr) {
    type CudaDevicePropWrapper (line 172) | struct CudaDevicePropWrapper {
      method CudaDevicePropWrapper (line 173) | CudaDevicePropWrapper() : props(NumCudaDevices()) {
    function cudaDeviceProp (line 182) | const cudaDeviceProp& GetDeviceProperty(const int deviceid) {
    function DeviceQuery (line 199) | void DeviceQuery(const int device) {
    function GetCudaPeerAccessPattern (line 234) | bool GetCudaPeerAccessPattern(vector<vector<bool> >* pattern) {
    function TensorCoreAvailable (line 254) | bool TensorCoreAvailable() {
    class CudaRuntimeFlagFlipper (line 333) | class CudaRuntimeFlagFlipper {
      method CudaRuntimeFlagFlipper (line 335) | CudaRuntimeFlagFlipper() {

FILE: caffe2/core/common_gpu.h
  function namespace (line 82) | namespace caffe2 {

FILE: caffe2/core/common_test.cc
  type caffe2 (line 25) | namespace caffe2 {
    function TEST (line 32) | TEST(CommonTest, TestStoi) {
    function TEST (line 40) | TEST(CommonTest, TestStod) {

FILE: caffe2/core/context.cc
  type caffe2 (line 24) | namespace caffe2 {
    function RandomNumberSeed (line 26) | uint32_t RandomNumberSeed() {

FILE: caffe2/core/context.h
  function namespace (line 33) | namespace caffe2 {

FILE: caffe2/core/context_gpu.h
  function namespace (line 32) | namespace caffe2 {
  function CPUAllocator (line 302) | struct PinnedCPUAllocator final : CPUAllocator {
  type Tensor (line 352) | typedef Tensor<CUDAContext> TensorCUDA;

FILE: caffe2/core/context_gpu_test.cc
  type caffe2 (line 29) | namespace caffe2 {
    function shared_from_new (line 32) | std::shared_ptr<void> shared_from_new(std::pair<void*, MemoryDeleter>&...
    function TEST (line 37) | TEST(CUDATest, HasCudaRuntime) {
    function TEST (line 41) | TEST(CUDAContextTest, TestAllocDealloc) {
    function TEST (line 49) | TEST(CUDAContextTest, TestSetGetDeviceWithoutCaffeMode) {
    function TEST (line 61) | TEST(CUDAContextTest, TestSetGetDeviceWithCaffeMode) {
    function TEST (line 75) | TEST(CUDAContextTest, MemoryPoolAllocateDealloc) {
    function cudaStream_t (line 104) | cudaStream_t getStreamForHandle(cublasHandle_t handle) {
    function TEST (line 111) | TEST(CUDAContextTest, TestSameThreadSameObject) {
    function TEST (line 123) | TEST(CUDAContextTest, TestSameThreadDifferntObjectIfDifferentDevices) {
    function TEST_GetStreamAddress (line 139) | void TEST_GetStreamAddress(cudaStream_t* ptr) {
    function TEST (line 147) | TEST(CUDAContextTest, TestDifferntThreadDifferentobject) {

FILE: caffe2/core/context_test.cc
  type caffe2 (line 23) | namespace caffe2 {
    function TEST (line 25) | TEST(CPUContextTest, TestAllocAlignment) {
    function TEST (line 33) | TEST(CPUContextTest, TestAllocDealloc) {

FILE: caffe2/core/cudnn_wrappers.h
  function reset (line 35) | void reset() {
  function nbytes_ (line 42) | size_t nbytes_{0}
  function class (line 49) | class CuDNNState {
  function cudaEvent_t (line 87) | cudaEvent_t before_{nullptr};

FILE: caffe2/core/db.cc
  type caffe2 (line 24) | namespace caffe2 {
    type db (line 29) | namespace db {
      class MiniDBCursor (line 38) | class MiniDBCursor : public Cursor {
        method MiniDBCursor (line 40) | explicit MiniDBCursor(FILE* f, std::mutex* mutex)
        method Seek (line 47) | void Seek(const string& /*key*/) override {
        method SeekToFirst (line 51) | void SeekToFirst() override {
        method Next (line 59) | void Next() override {
        method string (line 86) | string key() override {
        method string (line 91) | string value() override {
        method Valid (line 96) | bool Valid() override { return valid_; }
      class MiniDBTransaction (line 108) | class MiniDBTransaction : public Transaction {
        method MiniDBTransaction (line 110) | explicit MiniDBTransaction(FILE* f, std::mutex* mutex)
        method Put (line 116) | void Put(const string& key, const string& value) override {
        method Commit (line 127) | void Commit() override {
      class MiniDB (line 141) | class MiniDB : public DB {
        method MiniDB (line 143) | MiniDB(const string& source, Mode mode) : DB(source, mode), file_(...
        method Close (line 161) | void Close() override {
        method NewCursor (line 168) | unique_ptr<Cursor> NewCursor() override {
        method NewTransaction (line 173) | unique_ptr<Transaction> NewTransaction() override {

FILE: caffe2/core/db.h
  function namespace (line 26) | namespace caffe2 {
  function Cursor (line 270) | inline Cursor* cursor() const {
  function class (line 307) | class DBReaderSerializer : public BlobSerializerBase {
  function class (line 319) | class DBReaderDeserializer : public BlobDeserializerBase {

FILE: caffe2/core/event.cc
  type caffe2 (line 19) | namespace caffe2 {
    function EventCreateCPU (line 38) | void EventCreateCPU(const DeviceOption& option, Event* event) {
    function EventRecordCPU (line 42) | void EventRecordCPU(
    function EventFinishCPU (line 71) | void EventFinishCPU(const Event* event) {
    function EventWaitCPUCPU (line 80) | void EventWaitCPUCPU(const Event* event, void* /* context */) {
    function EventStatus (line 84) | EventStatus EventQueryCPU(const Event* event) {
    function EventSetFinishedCPU (line 100) | void EventSetFinishedCPU(const Event* event, const char* err_msg) {
    function EventResetCPU (line 118) | void EventResetCPU(Event* event) {

FILE: caffe2/core/event.h
  function namespace (line 24) | namespace caffe2 {
  function explicit (line 209) | explicit EventCreateFunctionRegisterer(EventCreateFunction f) {
  function explicit (line 221) | explicit EventRecordFunctionRegisterer(EventRecordFunction f) {
  function explicit (line 233) | explicit EventWaitFunctionRegisterer(EventWaitFunction f) {
  function explicit (line 246) | explicit EventQueryFunctionRegisterer(EventQueryFunction f) {
  function explicit (line 258) | explicit EventErrorMessageFunctionRegisterer(EventErrorMessageFunction f) {
  function explicit (line 270) | explicit EventSetFinishedFunctionRegisterer(EventSetFinishedFunction f) {
  function explicit (line 282) | explicit EventFinishFunctionRegisterer(EventFinishFunction f) {
  function explicit (line 294) | explicit EventResetFunctionRegisterer(EventResetFunction f) {

FILE: caffe2/core/event_cpu.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/core/event_gpu.cc
  type caffe2 (line 23) | namespace caffe2 {
    type CudaEventWrapper (line 25) | struct CudaEventWrapper {
      method CudaEventWrapper (line 26) | explicit CudaEventWrapper(const DeviceOption& option)
    function EventCreateCUDA (line 54) | void EventCreateCUDA(const DeviceOption& option, Event* event) {
    function EventRecordCUDA (line 58) | void EventRecordCUDA(Event* event, const void* context, const char* er...
    function EventFinishCUDA (line 104) | void EventFinishCUDA(const Event* event) {
    function EventWaitCUDACUDA (line 130) | void EventWaitCUDACUDA(const Event* event, void* context) {
    function EventWaitCPUCUDA (line 153) | void EventWaitCPUCUDA(const Event* event, void* context) {
    function EventWaitCUDACPU (line 158) | void EventWaitCUDACPU(const Event* event, void* context) {
    function EventStatus (line 162) | EventStatus EventQueryCUDA(const Event* event) {
    function EventSetFinishedCUDA (line 189) | void EventSetFinishedCUDA(const Event* event, const char* err_msg) {
    function EventResetCUDA (line 209) | void EventResetCUDA(Event* event) {

FILE: caffe2/core/event_gpu_test.cc
  type caffe2 (line 22) | namespace caffe2 {
    function TEST (line 24) | TEST(EventCUDATest, EventBasics) {

FILE: caffe2/core/event_test.cc
  type caffe2 (line 21) | namespace caffe2 {
    function TEST (line 23) | TEST(EventCPUTest, EventBasics) {

FILE: caffe2/core/flags.cc
  type caffe2 (line 24) | namespace caffe2 {
    function SetUsageMessage (line 28) | void SetUsageMessage(const string& str) {
    function ParseCaffeCommandLineFlags (line 40) | bool ParseCaffeCommandLineFlags(int* pargc, char*** pargv) {
    function CommandLineFlagsHasBeenParsed (line 45) | bool CommandLineFlagsHasBeenParsed() {
    function SetUsageMessage (line 68) | void SetUsageMessage(const string& str) { gUsageMessage = str; }
    function ParseCaffeCommandLineFlags (line 71) | bool ParseCaffeCommandLineFlags(int* pargc, char*** pargv) {
    function CommandLineFlagsHasBeenParsed (line 155) | bool CommandLineFlagsHasBeenParsed() {

FILE: caffe2/core/flags.h
  function namespace (line 41) | namespace caffe2 {
  function namespace (line 115) | namespace caffe2 {

FILE: caffe2/core/graph.cc
  type caffe2 (line 24) | namespace caffe2 {
    type transform (line 26) | namespace transform {
      function NetDef (line 117) | NetDef Graph::GetNetDef() {
    function OperatorDef (line 211) | OperatorDef* AddOp(
    function MatchStrings (line 230) | bool MatchStrings(string p, string s) {
    function MatchArguments (line 244) | bool MatchArguments(const OperatorDef& p_op, const OperatorDef& g_op) {

FILE: caffe2/core/graph.h
  function namespace (line 28) | namespace caffe2 {

FILE: caffe2/core/graph_test.cc
  type caffe2 (line 23) | namespace caffe2 {
    class GraphDummyOp (line 31) | class GraphDummyOp final : public OperatorBase {
      method Run (line 34) | bool Run(int /* unused */) override {
    function compare_netdefs (line 62) | void compare_netdefs(const NetDef& net_a, const NetDef& net_b) {
    function TEST (line 77) | TEST(GraphTest, TestGenerateGraphChain) {
    function TEST (line 101) | TEST(GraphTest, TestGenerateGraphChainInPlace) {
    function TEST (line 126) | TEST(GraphTest, TestGenerateGraphBranch) {
    function TEST (line 153) | TEST(GraphTest, TestReusedInputs) {
    function TEST (line 188) | TEST(GraphTest, TestGetPerimeter) {

FILE: caffe2/core/init.cc
  type caffe2 (line 25) | namespace caffe2 {
    type internal (line 27) | namespace internal {
      function Caffe2InitializeRegistry (line 28) | Caffe2InitializeRegistry* Caffe2InitializeRegistry::Registry() {
    function GlobalInit (line 34) | bool GlobalInit(int* pargc, char*** pargv) {

FILE: caffe2/core/init.h
  function namespace (line 24) | namespace caffe2 {
  function class (line 75) | class InitRegisterer {

FILE: caffe2/core/init_intrinsics_check.cc
  type caffe2 (line 30) | namespace caffe2 {
    function QuitIfFeatureUnsupported (line 32) | static void QuitIfFeatureUnsupported(
    function WarnIfFeatureUnused (line 50) | static void WarnIfFeatureUnused(
    function Caffe2CheckIntrinsicsFeatures (line 68) | bool Caffe2CheckIntrinsicsFeatures(int*, char***) {

FILE: caffe2/core/init_omp.cc
  type caffe2 (line 42) | namespace caffe2 {
    function Caffe2SetOpenMPThreads (line 45) | bool Caffe2SetOpenMPThreads(int*, char***) {
    function Caffe2SetMKLThreads (line 66) | bool Caffe2SetMKLThreads(int*, char***) {

FILE: caffe2/core/init_test.cc
  type caffe2 (line 23) | namespace caffe2 {
    function TestInitFunction (line 27) | bool TestInitFunction(int*, char***) {
    function TEST (line 41) | TEST(InitTest, TestInitFunctionHasRun) {
    function TEST (line 46) | TEST(InitTest, CanRerunGlobalInit) {

FILE: caffe2/core/logging.cc
  type caffe2 (line 30) | namespace caffe2 {
    function StripBasename (line 31) | std::string StripBasename(const std::string &full_path) {
    function ReplaceAll (line 41) | size_t ReplaceAll(string& s, const char* from, const char* to) {
    function SetStackTraceFetcher (line 58) | void SetStackTraceFetcher(std::function<string(void)> fetcher) {
    function SetOperatorLogger (line 65) | void SetOperatorLogger(std::function<void(const OperatorDef&)> tracer) {
    function GetOperatorLogger (line 69) | std::function<void(const OperatorDef&)> GetOperatorLogger() {
    function string (line 102) | string EnforceNotMet::msg() const {
    function InitCaffeLogging (line 151) | bool InitCaffeLogging(int* argc, char** argv) {
    function ShowLogInfoToStderr (line 178) | void ShowLogInfoToStderr() {
    function InitCaffeLogging (line 194) | bool InitCaffeLogging(int* argc, char** argv) {
    function ShowLogInfoToStderr (line 212) | void ShowLogInfoToStderr() {
  type google (line 143) | namespace google {
    type glog_internal_namespace_ (line 144) | namespace glog_internal_namespace_ {
  type caffe2 (line 150) | namespace caffe2 {
    function StripBasename (line 31) | std::string StripBasename(const std::string &full_path) {
    function ReplaceAll (line 41) | size_t ReplaceAll(string& s, const char* from, const char* to) {
    function SetStackTraceFetcher (line 58) | void SetStackTraceFetcher(std::function<string(void)> fetcher) {
    function SetOperatorLogger (line 65) | void SetOperatorLogger(std::function<void(const OperatorDef&)> tracer) {
    function GetOperatorLogger (line 69) | std::function<void(const OperatorDef&)> GetOperatorLogger() {
    function string (line 102) | string EnforceNotMet::msg() const {
    function InitCaffeLogging (line 151) | bool InitCaffeLogging(int* argc, char** argv) {
    function ShowLogInfoToStderr (line 178) | void ShowLogInfoToStderr() {
    function InitCaffeLogging (line 194) | bool InitCaffeLogging(int* argc, char** argv) {
    function ShowLogInfoToStderr (line 212) | void ShowLogInfoToStderr() {
  type caffe2 (line 193) | namespace caffe2 {
    function StripBasename (line 31) | std::string StripBasename(const std::string &full_path) {
    function ReplaceAll (line 41) | size_t ReplaceAll(string& s, const char* from, const char* to) {
    function SetStackTraceFetcher (line 58) | void SetStackTraceFetcher(std::function<string(void)> fetcher) {
    function SetOperatorLogger (line 65) | void SetOperatorLogger(std::function<void(const OperatorDef&)> tracer) {
    function GetOperatorLogger (line 69) | std::function<void(const OperatorDef&)> GetOperatorLogger() {
    function string (line 102) | string EnforceNotMet::msg() const {
    function InitCaffeLogging (line 151) | bool InitCaffeLogging(int* argc, char** argv) {
    function ShowLogInfoToStderr (line 178) | void ShowLogInfoToStderr() {
    function InitCaffeLogging (line 194) | bool InitCaffeLogging(int* argc, char** argv) {
    function ShowLogInfoToStderr (line 212) | void ShowLogInfoToStderr() {

FILE: caffe2/core/logging.h
  function IsUsingGoogleLogging (line 52) | constexpr bool IsUsingGoogleLogging() {
  function MakeStringInternal (line 70) | inline void MakeStringInternal(std::stringstream& /*ss*/) {}
  function MakeStringInternal (line 73) | void MakeStringInternal(std::stringstream& ss, const T& t) {
  function MakeStringInternal (line 78) | void
  function string (line 93) | inline string MakeString(const string& str) {
  function string (line 96) | inline string MakeString(const char* c_str) {
  function string (line 101) | string Join(const string& delimiter, const Container& v) {
  function namespace (line 194) | namespace enforce_detail {

FILE: caffe2/core/logging_is_not_google_glog.h
  function namespace (line 45) | namespace caffe2 {
  function class (line 65) | class LoggerVoidify {
  function namespace (line 185) | namespace caffe2 {

FILE: caffe2/core/logging_test.cc
  type caffe2 (line 22) | namespace caffe2 {
    function TEST (line 24) | TEST(LoggingTest, TestEnforceTrue) {
    function TEST (line 29) | TEST(LoggingTest, TestEnforceFalse) {
    function TEST (line 41) | TEST(LoggingTest, TestEnforceEquals) {
    function TEST (line 58) | TEST(LoggingTest, EnforceShowcase) {
  function TEST (line 83) | TEST(LoggingTest, Join) {
  function TEST (line 93) | TEST(LoggingDeathTest, TestEnforceUsingFatal) {

FILE: caffe2/core/memonger.cc
  type caffe2 (line 25) | namespace caffe2 {
    type memonger (line 26) | namespace memonger {
      function NetDef (line 28) | NetDef optimize_inference_net(
      class ComputeBlobRecyclingForDag (line 143) | class ComputeBlobRecyclingForDag {
        method ComputeBlobRecyclingForDag (line 145) | explicit ComputeBlobRecyclingForDag(const int size)
        method NetDef (line 150) | NetDef OptimizeNet(
        method NetDef (line 264) | NetDef apply_assignments(const NetDef& net) {
        method apply_recurrent_blob_assignments (line 289) | void apply_recurrent_blob_assignments(OperatorDef* op) {
        method has_key (line 334) | inline bool has_key(const std::unordered_map<K, V>& in_map, const ...
        method has_key (line 339) | inline bool has_key(const std::unordered_set<K>& in_set, const K& ...
        method process_op (line 343) | void process_op(
        method infer_blob_size (line 468) | inline int infer_blob_size(
        method string (line 482) | inline string get_blob_or_mapped_blob(const string& blob_name) {
        method can_use_blob (line 492) | inline bool can_use_blob(
        method string (line 510) | inline string get_free_blob(
      function NetDef (line 590) | NetDef compute_blob_recycling_for_dag(

FILE: caffe2/core/memonger.h
  function namespace (line 26) | namespace caffe2 {

FILE: caffe2/core/module.cc
  type caffe2 (line 24) | namespace caffe2 {
    function CurrentModuleHandles (line 38) | static CaffeMap<string, void*> CurrentModuleHandles() {
    function HasModule (line 53) | bool HasModule(const string& name) {
    function LoadModule (line 60) | void LoadModule(const string& name, const string& filename) {
    function LoadModule (line 68) | void LoadModule(const string& name, const string& filename) {

FILE: caffe2/core/module.h
  function namespace (line 35) | namespace caffe2 {

FILE: caffe2/core/module_test.cc
  type caffe2 (line 29) | namespace caffe2 {
    class Caffe2ModuleTestStaticDummyOp (line 31) | class Caffe2ModuleTestStaticDummyOp : public OperatorBase {
      method Run (line 34) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 37) | virtual string type() {
    function TEST (line 46) | TEST(ModuleTest, StaticModule) {
    function TEST (line 68) | TEST(ModuleTest, DynamicModule) {

FILE: caffe2/core/net.cc
  type caffe2 (line 29) | namespace caffe2 {
    function SetGlobalNetObserverCreator (line 112) | void SetGlobalNetObserverCreator(NetObserverCreator creator) {
    function CreateNet (line 117) | unique_ptr<NetBase> CreateNet(const NetDef& net_def, Workspace* ws) {
    function CreateNet (line 122) | unique_ptr<NetBase> CreateNet(

FILE: caffe2/core/net.h
  function namespace (line 39) | namespace caffe2 {
  function virtual (line 93) | virtual vector<float> TEST_Benchmark(
  function virtual (line 114) | virtual vector<OperatorBase*> GetOperators() const = 0;

FILE: caffe2/core/net_async_base.cc
  type caffe2 (line 54) | namespace caffe2 {
    function Event (line 182) | Event& AsyncNetBase::event(int task_id) const {
    function EventStatus (line 188) | EventStatus AsyncNetBase::query(int task_id) const {
    function CAFFE_DEFINE_SHARED_REGISTRY (line 257) | CAFFE_DEFINE_SHARED_REGISTRY(
    function GetAsyncNetCPUThreadPool (line 276) | std::shared_ptr<TaskThreadPool> GetAsyncNetCPUThreadPool(int numa_node...

FILE: caffe2/core/net_async_base.h
  function namespace (line 31) | namespace caffe2 {

FILE: caffe2/core/net_async_dag_gpu.cc
  type caffe2 (line 51) | namespace caffe2 {
    class ProfiledRange (line 64) | class ProfiledRange {
      method ProfiledRange (line 66) | ProfiledRange(const OperatorDef& def, Color color) {
      method ProfiledRange (line 97) | ProfiledRange(const OperatorDef& def, Color color) {}
    class ProfiledRange (line 95) | class ProfiledRange {
      method ProfiledRange (line 66) | ProfiledRange(const OperatorDef& def, Color color) {
      method ProfiledRange (line 97) | ProfiledRange(const OperatorDef& def, Color color) {}

FILE: caffe2/core/net_async_dag_gpu.h
  function namespace (line 25) | namespace caffe2 {

FILE: caffe2/core/net_async_gpu_thread_pool.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/core/net_async_gpu_thread_pool_gpu.cc
  type caffe2 (line 23) | namespace caffe2 {
    function AsyncNetGPUThreadPoolCreator (line 26) | std::shared_ptr<TaskThreadPool> AsyncNetGPUThreadPoolCreator(
    function GetAsyncNetGPUThreadPool (line 38) | std::shared_ptr<TaskThreadPool> GetAsyncNetGPUThreadPool(int gpu_id) {

FILE: caffe2/core/net_async_polling.cc
  type caffe2 (line 24) | namespace caffe2 {

FILE: caffe2/core/net_async_polling.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/core/net_async_scheduling.cc
  type caffe2 (line 24) | namespace caffe2 {

FILE: caffe2/core/net_async_scheduling.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/core/net_dag.cc
  type caffe2 (line 40) | namespace caffe2 {

FILE: caffe2/core/net_dag.h
  function namespace (line 42) | namespace caffe2 {

FILE: caffe2/core/net_dag_utils.cc
  type caffe2 (line 30) | namespace caffe2 {
    type dag_utils (line 31) | namespace dag_utils {
      function prune (line 34) | void prune(int node_idx, std::vector<OpGraphNode>& nodes) {
      function pruneOpNodeGraph (line 95) | std::vector<OpGraphNode> pruneOpNodeGraph(
      function updateOperatorNodes (line 123) | void updateOperatorNodes(
      function ExecutionChains (line 138) | ExecutionChains computeChains(std::vector<OperatorNode>& orig_nodes) {
      function ExecutionChains (line 296) | ExecutionChains singleChains(std::vector<OperatorNode>& nodes) {
      function prepareOperatorNodes (line 305) | std::vector<OperatorNode> prepareOperatorNodes(
      function prepareChainGraphNodes (line 397) | std::vector<OpGraphNode> prepareChainGraphNodes(

FILE: caffe2/core/net_dag_utils.h
  function namespace (line 41) | namespace caffe2 {

FILE: caffe2/core/net_gpu_test.cc
  type caffe2 (line 27) | namespace caffe2 {
    class NetTestDummyOp (line 36) | class NetTestDummyOp final : public OperatorBase {
      method NetTestDummyOp (line 40) | NetTestDummyOp(const OperatorDef& operator_def, Workspace* ws)
      method Run (line 44) | bool Run(int /* unused */ /*stream_id*/) override {
      method HasAsyncPart (line 53) | bool HasAsyncPart() const override {
      method SupportsAsyncScheduling (line 57) | bool SupportsAsyncScheduling() const override {
    function testExecution (line 81) | void testExecution(std::unique_ptr<NetBase>& net, int num_ops) {
    function checkChainingAndRun (line 90) | void checkChainingAndRun(
    function TEST (line 112) | TEST(NetTest, DISABLED_ChainingForDifferentDevices) {

FILE: caffe2/core/net_simple.cc
  type caffe2 (line 30) | namespace caffe2 {
    function PairLargerThan (line 92) | bool PairLargerThan(const std::pair<A, B>& x, const std::pair<A, B>& y) {

FILE: caffe2/core/net_simple.h
  function namespace (line 30) | namespace caffe2 {

FILE: caffe2/core/net_simple_async.cc
  type caffe2 (line 30) | namespace caffe2 {

FILE: caffe2/core/net_simple_async.h
  function namespace (line 30) | namespace caffe2 {

FILE: caffe2/core/net_singlethread_async_gpu.cc
  type caffe2 (line 30) | namespace caffe2 {
    type gpu_single_thread (line 32) | namespace gpu_single_thread {
      type Task (line 34) | struct Task {
      class GPUExecutor (line 42) | class GPUExecutor {
        method GPUExecutor (line 44) | explicit GPUExecutor(int gpu_id) : gpu_id_(gpu_id) {}
        method RunJob (line 51) | void RunJob(Task* task) {
        method start (line 55) | void start() {
      class SingleThreadAsyncNet (line 168) | class SingleThreadAsyncNet : public SimpleNet {
        method Run (line 181) | bool Run() override {
        method initialize (line 206) | void initialize() {

FILE: caffe2/core/net_test.cc
  type caffe2 (line 26) | namespace caffe2 {
    class NetTestDummyOp (line 35) | class NetTestDummyOp final : public OperatorBase {
      method NetTestDummyOp (line 39) | NetTestDummyOp(const OperatorDef& operator_def, Workspace* ws)
      method Run (line 43) | bool Run(int /* unused */ /*stream_id*/) override {
      method HasAsyncPart (line 52) | bool HasAsyncPart() const override {
      method SupportsAsyncScheduling (line 56) | bool SupportsAsyncScheduling() const override {
    function CreateNetTestHelper (line 78) | unique_ptr<NetBase> CreateNetTestHelper(
    function TEST (line 107) | TEST(NetTest, ConstructionNoDeclaredInputOutput) {
    function TEST (line 115) | TEST(NetTest, ConstructionDeclaredInput) {
    function TEST (line 123) | TEST(NetTest, ConstructionDeclaredOutput) {
    function TEST (line 131) | TEST(NetTest, DeclaredInputInsufficient) {
    function TEST (line 140) | TEST(NetDeathTest, DeclaredOutputNotMet) {
    function testExecution (line 149) | void testExecution(std::unique_ptr<NetBase>& net, int num_ops) {
    function checkChainingAndRun (line 158) | void checkChainingAndRun(
    function checkNumChainsAndRun (line 180) | void checkNumChainsAndRun(const char* spec, const int expected_num_cha...
    function TEST (line 206) | TEST(NetTest, ChainingForLinearModel) {
    function TEST (line 225) | TEST(NetTest, ChainingForFork) {
    function TEST (line 278) | TEST(NetTest, ChainingForForkJoin) {
    function TEST (line 308) | TEST(NetTest, ChainingForwardBackward) {
    function TEST (line 519) | TEST(NetTest, ChainingForHogwildModel) {
    function TEST (line 558) | TEST(NetTest, FailingOperator) {

FILE: caffe2/core/numa.cc
  type caffe2 (line 30) | namespace caffe2 {
    function IsNUMAEnabled (line 33) | bool IsNUMAEnabled() {
    function NUMABind (line 37) | void NUMABind(int numa_node_id) {
    function GetNUMANode (line 57) | int GetNUMANode(const void* ptr) {
    function GetNumNUMANodes (line 72) | int GetNumNUMANodes() {
    function NUMAMove (line 81) | void NUMAMove(void* ptr, size_t size, int numa_node_id) {
    function GetCurrentNUMANode (line 107) | int GetCurrentNUMANode() {
    function IsNUMAEnabled (line 118) | bool IsNUMAEnabled() {
    function NUMABind (line 122) | void NUMABind(int numa_node_id) {
    function GetNUMANode (line 128) | int GetNUMANode(const void* ptr) {
    function GetNumNUMANodes (line 133) | int GetNumNUMANodes() {
    function NUMAMove (line 138) | void NUMAMove(void* ptr, size_t size, int numa_node_id) {
    function GetCurrentNUMANode (line 144) | int GetCurrentNUMANode() {

FILE: caffe2/core/numa.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/core/observer.h
  function virtual (line 34) | virtual void Start() {}
  function virtual (line 35) | virtual void Stop() {}
  function virtual (line 37) | virtual std::unique_ptr<ObserverBase<T>> copy(T* subject) {
  function virtual (line 42) | virtual std::string debugInfo() {
  function virtual (line 46) | virtual ~ObserverBase() noexcept {}
  function T (line 48) | T* subject() const {

FILE: caffe2/core/observer_test.cc
  type caffe2 (line 28) | namespace caffe2 {
    class DummyObserver (line 35) | class DummyObserver final : public ObserverBase<T> {
    class ObsTestDummyOp (line 68) | class ObsTestDummyOp final : public OperatorBase {
      method Run (line 71) | bool Run(int /* unused */) override {
    function CreateNetTestHelper (line 86) | unique_ptr<NetBase> CreateNetTestHelper(Workspace* ws, bool isDAG = fa...
    function TEST (line 110) | TEST(ObserverTest, TestNotify) {
    function TEST (line 125) | TEST(ObserverTest, TestUniqueMap) {
    function TEST (line 142) | TEST(ObserverTest, TestNotifyAfterDetach) {
    function TEST (line 157) | TEST(ObserverTest, TestDAGNetBase) {
    function TEST (line 172) | TEST(ObserverTest, TestMultipleNetBase) {

FILE: caffe2/core/operator.cc
  type caffe2 (line 42) | namespace caffe2 {
    function PerOpEnginePrefType (line 79) | PerOpEnginePrefType& g_per_op_engine_pref() {
    function GlobalEnginePrefType (line 84) | GlobalEnginePrefType& g_global_engine_pref() {
    function TryCreateOperator (line 90) | unique_ptr<OperatorBase> TryCreateOperator(
    function _CreateOperator (line 111) | unique_ptr<OperatorBase> _CreateOperator(
    function OpRegistryKey (line 201) | const std::string OpRegistryKey(
    function SetPerOpEnginePref (line 211) | void SetPerOpEnginePref(const PerOpEnginePrefType& per_op_engine_pref) {
    function SetGlobalEnginePref (line 235) | void SetGlobalEnginePref(const GlobalEnginePrefType& global_engine_pre...
    function SetEnginePref (line 247) | void SetEnginePref(
    function SetOpEnginePref (line 254) | void SetOpEnginePref(
    function CreateOperator (line 275) | unique_ptr<OperatorBase> CreateOperator(
    function GradientOpsMeta (line 319) | GradientOpsMeta GetGradientForOp(
    function TensorShapes (line 373) | static TensorShapes InferBlobShapesAndTypes(
    function TensorShape (line 522) | TensorShape GetTensorShapeOfBlob(const Blob* b) {
    function TensorShapes (line 545) | TensorShapes InferBlobShapesAndTypesFromWorkspace(
    function TensorShapes (line 559) | TensorShapes InferBlobShapesAndTypesFromMap(
    function ValidateTensorDevices (line 575) | std::map<string, std::pair<DeviceOption, DeviceOption>> ValidateTensor...
    function GetRegisteredOperators (line 620) | std::set<std::string> GetRegisteredOperators() {

FILE: caffe2/core/operator.h
  function namespace (line 41) | namespace caffe2 {
  function noexcept (line 339) | noexcept override {}
  function Tensor (line 341) | inline const Tensor<Context>& Input(int idx) {
  function Tensor (line 344) | inline Tensor<Context>* Output(int idx) {
  function IsStreamFree (line 435) | bool IsStreamFree(int stream_id) const override {
  type GenericTensorImplementation (line 555) | struct GenericTensorImplementation {}
  function call (line 567) | bool call(Op* op, int value) {
  function call (line 579) | bool call(Op* op, TIndex /*size*/) {
  type Registry (line 657) | typedef Registry<
  type Registry (line 663) | typedef Registry<
  type DeviceTypeRegisterer (line 670) | struct DeviceTypeRegisterer {
  function class (line 770) | class UnsupportedOperatorFeature : public std::exception {

FILE: caffe2/core/operator_gpu_test.cc
  type caffe2 (line 23) | namespace caffe2 {
    class JustTest (line 25) | class JustTest : public OperatorBase {
      method Run (line 28) | bool Run(int /* unused */ /*stream_id*/) override {
      method type (line 31) | virtual std::string type() {
    class JustTestCUDA (line 36) | class JustTestCUDA : public JustTest {
      method Run (line 39) | bool Run(int /* unused */ /*stream_id*/) override {
      method type (line 42) | std::string type() override {
    class JustTestCUDNN (line 47) | class JustTestCUDNN : public JustTest {
      method Run (line 50) | bool Run(int /* unused */ /*stream_id*/) override {
      method type (line 53) | std::string type() override {
    function TEST (line 62) | TEST(EnginePrefTest, GPUDeviceDefaultPreferredEngines) {

FILE: caffe2/core/operator_gradient.h
  function namespace (line 25) | namespace caffe2 {
  type GradientOpsMeta (line 52) | struct GradientOpsMeta {
  function virtual (line 101) | virtual GradientOpsMeta Get() {
  function GradientMakerBase (line 288) | struct ThrowInTheTowelIfGradientIsCalled : public GradientMakerBase {
  function GradientMakerBase (line 303) | struct GradientNotImplementedYet : public GradientMakerBase {

FILE: caffe2/core/operator_schema.cc
  type caffe2 (line 21) | namespace caffe2 {
    function OpSchema (line 109) | OpSchema& OpSchema::NumInputs(int min, int max) {
    function OpSchema (line 115) | OpSchema& OpSchema::NumInputs(int n) {
    function OpSchema (line 119) | OpSchema& OpSchema::NumInputs(std::function<bool(int)> func) {
    function OpSchema (line 124) | OpSchema& OpSchema::NumInputs(set<int> allowed_input_nums) {
    function OpSchema (line 131) | OpSchema& OpSchema::NumOutputs(int min, int max) {
    function OpSchema (line 137) | OpSchema& OpSchema::NumOutputs(int n) {
    function OpSchema (line 141) | OpSchema& OpSchema::NumOutputs(std::function<bool(int)> func) {
    function OpSchema (line 146) | OpSchema& OpSchema::NumOutputs(set<int> allowed_output_nums) {
    function OpSchema (line 153) | OpSchema& OpSchema::NumInputsOutputs(std::function<bool(int, int)> fun...
    function OpSchema (line 158) | OpSchema& OpSchema::OutputCalculator(std::function<int(int)> calc) {
    function OpSchema (line 163) | OpSchema& OpSchema::SameNumberOfOutput() {
    function OpSchema (line 167) | OpSchema& OpSchema::AllowInplace(std::function<bool(int, int)> inplace) {
    function OpSchema (line 172) | OpSchema& OpSchema::AllowInplace(set<std::pair<int, int>> inplace) {
    function OpSchema (line 179) | OpSchema& OpSchema::AllowOneToOneInplace() {
    function OpSchema (line 183) | OpSchema& OpSchema::EnforceInplace(std::function<bool(int, int)> inpla...
    function OpSchema (line 188) | OpSchema& OpSchema::EnforceInplace(set<std::pair<int, int>> inplace) {
    function OpSchema (line 195) | OpSchema& OpSchema::EnforceOneToOneInplace() {
    function OpSchema (line 199) | OpSchema& OpSchema::Private() {
    function OpSchema (line 204) | OpSchema& OpSchema::InputsCanCrossDevices() {
    function OpSchema (line 209) | OpSchema& OpSchema::TensorInferenceFunction(
    function OpSchema (line 215) | OpSchema& OpSchema::IdenticalTypeAndShape() {
    function OpSchema (line 222) | OpSchema& OpSchema::IdenticalTypeAndShapeOfInput(int idx) {
    function OpSchema (line 231) | OpSchema& OpSchema::IdenticalTypeAndShapeOfInputDim(int idx, int dim) {
    function OpSchema (line 241) | OpSchema& OpSchema::ScalarType(::caffe2::TensorProto_DataType dt) {
    function OpSchema (line 250) | OpSchema& OpSchema::CostInferenceFunction(CostInferenceFunctionType fu...
    function OpSchema (line 256) | OpSchema& OpSchema::DeviceInferenceFunction(
    function OpSchema (line 262) | OpSchema& OpSchema::SetDoc(const string& doc) {
    function OpSchema (line 267) | OpSchema&
    function OpSchema (line 283) | OpSchema& OpSchema::Input(const int n, const char* name, const char* d...
    function OpSchema (line 291) | OpSchema& OpSchema::Output(const int n, const char* name, const char* ...
    function OpSchema (line 299) | OpSchema& OpSchema::FillUsing(std::function<void(OpSchema&)> populator) {

FILE: caffe2/core/operator_schema.h
  function namespace (line 32) | namespace caffe2 {
  function TensorInferenceFunctionType (line 381) | TensorInferenceFunctionType tensor_inference_function_ =
  function DeviceInferenceFunctionType (line 392) | DeviceInferenceFunctionType device_inference_function_ =
  function class (line 405) | class OpSchemaRegistry {
  function OpSchema (line 423) | static const OpSchema* Schema(const string& key) {

FILE: caffe2/core/operator_schema_test.cc
  type caffe2 (line 24) | namespace caffe2 {
    function TEST (line 32) | TEST(OperatorSchemaTest, BasicSchema) {
    function TEST (line 57) | TEST(OperatorSchemaTest, SpecifiedInputOutput) {
    function TEST (line 84) | TEST(OperatorSchemaTest, InputOutputRelation) {
    function TEST (line 109) | TEST(OperatorSchemaTest, SameInputOutput) {
    function TEST (line 134) | TEST(OperatorSchemaTest, CalculateOutput) {
    function TEST (line 160) | TEST(OperatorSchemaTest, Inplace) {
    function TEST (line 187) | TEST(OperatorSchemaTest, TensorInferenceIdentical) {
    function TEST (line 218) | TEST(OperatorSchemaTest, TensorInferenceArbitrary) {
    function TEST (line 237) | TEST(OperatorSchemaTest, TestCastSchema) {
    type OpSchema::Cost (line 269) | struct OpSchema::Cost
    function TEST (line 274) | TEST(OperatorSchemaTest, TestCostInference) {

FILE: caffe2/core/operator_test.cc
  type caffe2 (line 23) | namespace caffe2 {
    class JustTest (line 28) | class JustTest : public OperatorBase {
      method Run (line 31) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 34) | virtual string type() {
    class JustTestAndNeverConstructs (line 39) | class JustTestAndNeverConstructs : public JustTest {
      method JustTestAndNeverConstructs (line 41) | JustTestAndNeverConstructs(const OperatorDef& def, Workspace* ws)
      method Run (line 45) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 48) | string type() override {
    class JustTestAndDoesConstruct (line 53) | class JustTestAndDoesConstruct : public JustTest {
      method Run (line 56) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 59) | string type() override {
    class JustTestWithSomeOutput (line 64) | class JustTestWithSomeOutput : public JustTest {
      method Run (line 67) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 71) | string type() override {
    class ThrowException (line 76) | class ThrowException : public Operator<CPUContext> {
      method ThrowException (line 78) | explicit ThrowException(const OperatorDef& op_def, Workspace* ws)
      method RunOnDevice (line 80) | bool RunOnDevice() override {
    function TEST (line 99) | TEST(OperatorTest, DeviceTypeRegistryWorks) {
    function TEST (line 103) | TEST(OperatorTest, RegistryWorks) {
    function TEST (line 119) | TEST(OperatorTest, RegistryWrongDevice) {
    function TEST (line 132) | TEST(OperatorTest, ExceptionWorks) {
    function TEST (line 155) | TEST(OperatorTest, FallbackIfEngineDoesNotBuild) {
    function TEST (line 165) | TEST(OperatorTest, MultipleEngineChoices) {
    function TEST (line 175) | TEST(OperatorTest, CannotUseUninitializedBlob) {
    function TEST (line 185) | TEST(OperatorTest, TestParameterAccess) {
    function TEST (line 211) | TEST(OperatorTest, CannotAccessParameterWithWrongType) {
    function TEST (line 226) | TEST(OperatorDeathTest, DISABLED_CannotAccessRepeatedParameterWithWron...
    function TEST (line 244) | TEST(OperatorTest, TestDefaultValue) {
    function TEST (line 251) | TEST(OperatorTest, TestSetUp) {
    function TEST (line 264) | TEST(OperatorTest, TestSetUpInputOutputCount) {
    function TEST (line 288) | TEST(OperatorTest, TestOutputValues) {
    function NetDef (line 304) | NetDef GetNetDefForTest() {
    function TEST (line 320) | TEST(NetTest, TestScaffoldingSimpleNet) {
    function TEST (line 333) | TEST(NetTest, TestScaffoldingDAGNet) {
    class GetFooGradient (line 347) | class GetFooGradient : public GradientMakerBase {
      method GetGradientDefs (line 349) | vector<OperatorDef> GetGradientDefs() override {
    function TEST (line 360) | TEST(OperatorGradientRegistryTest, GradientSimple) {
    function TEST (line 391) | TEST(EnginePrefTest, PerOpEnginePref) {
    function TEST (line 411) | TEST(EnginePrefTest, GlobalEnginePref) {
    function TEST (line 438) | TEST(EnginePrefTest, GlobalEnginePrefAndPerOpEnginePref) {
    function TEST (line 456) | TEST(EnginePrefTest, GlobalEnginePrefAndPerOpEnginePrefAndOpDef) {
    function TEST (line 475) | TEST(EnginePrefTest, SetOpEnginePref) {
    function TEST (line 493) | TEST(EnginePrefTest, SetDefaultEngine) {
    class JustTestWithRequiredArg (line 511) | class JustTestWithRequiredArg : public JustTest {
      method Run (line 514) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 517) | string type() override {
    function TEST (line 528) | TEST(RequiredArg, Basic) {
    class JustTestWithStandardIsTestArg (line 551) | class JustTestWithStandardIsTestArg : public JustTest {
      method Run (line 554) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 557) | string type() override {
    function TEST (line 570) | TEST(IsTestArg, standard) {
    class JustTestWithNonStandardIsTestArg (line 594) | class JustTestWithNonStandardIsTestArg : public JustTest {
      method Run (line 597) | bool Run(int /* unused */ /*stream_id*/) override {
      method string (line 600) | string type() override {
    function TEST (line 613) | TEST(IsTestArg, non_standard) {

FILE: caffe2/core/parallel_net_test.cc
  type caffe2 (line 26) | namespace caffe2 {
    class SleepOp (line 38) | class SleepOp final : public Operator<CPUContext> {
      method SleepOp (line 40) | SleepOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDevice (line 47) | bool RunOnDevice() override {
    function RunNetAndGetDuration (line 104) | int RunNetAndGetDuration(const string& net_def_str, const string& type) {
    function TEST (line 123) | TEST(DAGNetTest, TestDAGNetTiming) {
    function TEST (line 130) | TEST(SimpleNetTest, TestSimpleNetTiming) {
    function TEST (line 172) | TEST(DAGNetTest, TestDAGNetTimingReadAfterRead) {
    function TEST (line 179) | TEST(SimpleNetTest, TestSimpleNetTimingReadAfterRead) {
    function TEST (line 220) | TEST(DAGNetTest, TestDAGNetTimingWriteAfterWrite) {
    function TEST (line 226) | TEST(SimpleNetTest, TestSimpleNetTimingWriteAfterWrite) {
    function TEST (line 268) | TEST(DAGNetTest, TestDAGNetTimingWriteAfterRead) {
    function TEST (line 274) | TEST(SimpleNetTest, TestSimpleNetTimingWriteAfterRead) {
    function TEST (line 318) | TEST(DAGNetTest, TestDAGNetTimingControlDependency) {
    function TEST (line 324) | TEST(SimpleNetTest, TestSimpleNetTimingControlDependency) {

FILE: caffe2/core/plan_executor.cc
  type caffe2 (line 36) | namespace caffe2 {
    type NetDefInfo (line 40) | struct NetDefInfo {
    type Reporter (line 50) | struct Reporter {
      type ReporterInstance (line 51) | struct ReporterInstance {
        method ReporterInstance (line 55) | ReporterInstance(int intervalMillis, bool* done, std::function<voi...
      method start (line 68) | void start(int64_t intervalMillis, std::function<void()> f) {
    function getContinuationTest (line 90) | std::function<bool(int64_t)> getContinuationTest(
    function getShouldStop (line 118) | inline bool getShouldStop(const Blob* b) {
    type WorkspaceIdInjector (line 136) | struct WorkspaceIdInjector {
      method InjectWorkspaceId (line 140) | void InjectWorkspaceId(Workspace* workspace) {
    type CompiledExecutionStep (line 165) | struct CompiledExecutionStep
      method CompiledExecutionStep (line 256) | CompiledExecutionStep(
    type ExecutionStepWrapper (line 186) | struct ExecutionStepWrapper {
      method ExecutionStepWrapper (line 187) | ExecutionStepWrapper(
      class CompiledGuard (line 206) | class CompiledGuard {
        method reset (line 207) | void reset(std::unique_ptr<CompiledExecutionStep>&& compiled) {
        method reset (line 211) | void reset(CompiledExecutionStep* compiledRef) {
        method CompiledExecutionStep (line 217) | CompiledExecutionStep* operator->() {
        method CompiledGuard (line 222) | CompiledGuard() {}
      method ExecutionStep (line 228) | const ExecutionStep& step() {
      method CompiledGuard (line 232) | CompiledGuard compiled() {
        method reset (line 207) | void reset(std::unique_ptr<CompiledExecutionStep>&& compiled) {
        method reset (line 211) | void reset(CompiledExecutionStep* compiledRef) {
        method CompiledExecutionStep (line 217) | CompiledExecutionStep* operator->() {
        method CompiledGuard (line 222) | CompiledGuard() {}
    type CompiledExecutionStep (line 253) | struct CompiledExecutionStep {
      method CompiledExecutionStep (line 256) | CompiledExecutionStep(
    function ExecuteStepRecursive (line 372) | bool ExecuteStepRecursive(ExecutionStepWrapper& stepWrapper) {
    function RunPlanOnWorkspace (line 494) | bool RunPlanOnWorkspace(

FILE: caffe2/core/plan_executor.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/core/predictor.cc
  type caffe2 (line 21) | namespace caffe2 {
    function enforceIsTensor (line 25) | void enforceIsTensor(Workspace* ws, const std::string& name) {
    function shareInputTensor (line 32) | void shareInputTensor(
    function TensorCPU (line 44) | TensorCPU* extractOutputTensor(Workspace* ws, const std::string& name) {
    function NetDef (line 51) | const NetDef& getNet(const MetaNetDef& def, const std::string& name) {

FILE: caffe2/core/predictor.h
  function namespace (line 25) | namespace caffe2 {

FILE: caffe2/core/predictor_test.cc
  type caffe2 (line 26) | namespace caffe2 {
    function randomTensor (line 147) | std::unique_ptr<Blob> randomTensor(
    function NetDef (line 158) | NetDef parseNetDef(const std::string& value) {
    function MetaNetDef (line 167) | MetaNetDef parseMetaNetDef(const std::string& value) {
    class PredictorTest (line 177) | class PredictorTest : public testing::Test {
      method SetUp (line 179) | void SetUp() override {
    function TEST_F (line 192) | TEST_F(PredictorTest, SimpleBatchSized) {
    function TEST_F (line 204) | TEST_F(PredictorTest, SimpleBatchSizedMapInput) {
    class PredictorMetaNetDefTest (line 217) | class PredictorMetaNetDefTest : public testing::Test {
      method SetUp (line 219) | void SetUp() override {
    function TEST_F (line 230) | TEST_F(PredictorMetaNetDefTest, SimpleMetaNetDefInitializer) {

FILE: caffe2/core/qtensor.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/core/qtensor.h
  function namespace (line 30) | namespace caffe2 {
  function SetScale (line 131) | void SetScale(const double scale) {
  function SetBias (line 135) | void SetBias(const double bias) {
  function dim32 (line 201) | inline int dim32(const int i) const {
  function canonical_axis_index (line 219) | inline int canonical_axis_index(int axis_index) const {
  function TIndex (line 231) | inline TIndex size_from_dim(int k) const {
  function TIndex (line 242) | inline TIndex size_to_dim(int k) const {

FILE: caffe2/core/qtensor_serialization.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/core/qtensor_serialization.h
  function namespace (line 23) | namespace caffe2 {
  function Context (line 85) | Context context{}

FILE: caffe2/core/registry.h
  function namespace (line 34) | namespace caffe2 {
  function ObjectPtrType (line 137) | ObjectPtrType DefaultCreator(Args... args) {

FILE: caffe2/core/registry_test.cc
  type caffe2 (line 24) | namespace caffe2 {
    class Foo (line 27) | class Foo {
      method Foo (line 29) | explicit Foo(int x) { LOG(INFO) << "Foo " << x; }
    class Bar (line 37) | class Bar : public Foo {
      method Bar (line 39) | explicit Bar(int x) : Foo(x) { LOG(INFO) << "Bar " << x; }
    class AnotherBar (line 43) | class AnotherBar : public Foo {
      method AnotherBar (line 45) | explicit AnotherBar(int x) : Foo(x) {
    function TEST (line 51) | TEST(RegistryTest, CanRunCreator) {
    function TEST (line 58) | TEST(RegistryTest, ReturnNullOnNonExistingCreator) {

FILE: caffe2/core/scope_guard.h
  function namespace (line 30) | namespace caffe2 {

FILE: caffe2/core/stats.cc
  type caffe2 (line 22) | namespace caffe2 {
    function ExportedStatMap (line 24) | ExportedStatMap toMap(const ExportedStatList& stats) {
    function StatValue (line 33) | StatValue* StatRegistry::add(const std::string& name) {
    function StatRegistry (line 65) | StatRegistry& StatRegistry::get() {

FILE: caffe2/core/stats.h
  function namespace (line 28) | namespace caffe2 {
  type ExportedStatValue (line 47) | struct ExportedStatValue {
  function class (line 133) | class StatRegistry {
  type Stat (line 172) | struct Stat {
  function class (line 183) | class ExportedStat : public Stat {
  function class (line 200) | class AvgExportedStat : public ExportedStat {
  function class (line 219) | class StdDevExportedStat : public ExportedStat {

FILE: caffe2/core/stats_test.cc
  type caffe2 (line 24) | namespace caffe2 {
    type MyCaffeClass (line 27) | struct MyCaffeClass {
      method MyCaffeClass (line 28) | explicit MyCaffeClass(const std::string& name) : stats_(name) {}
      method tryRun (line 30) | void tryRun(int) {}
      method run (line 32) | void run(int numRuns) {
      type MyStats (line 44) | struct MyStats {
    function ExportedStatMap (line 53) | ExportedStatMap filterMap(
    function TEST (line 67) | TEST(StatsTest, StatsTestClass) {
    function TEST (line 86) | TEST(StatsTest, StatsTestDuration) {
    function TEST (line 107) | TEST(StatsTest, StatsTestSimple) {

FILE: caffe2/core/tensor.cc
  type caffe2 (line 33) | namespace caffe2 {
    function TypeCall (line 68) | TypeCall GetTypeCallFunction(CaffeTypeId id) {
    function RegisterTypeCallFunction (line 76) | void RegisterTypeCallFunction(CaffeTypeId id, TypeCall c) {
    function TensorInfoCall (line 83) | TensorInfoCall GetTensorInfoFunction(CaffeTypeId id) {
    function RegisterTensorInfoFunction (line 91) | void RegisterTensorInfoFunction(CaffeTypeId id, TensorInfoCall c) {
    type TensorCPUStatGetter (line 97) | struct TensorCPUStatGetter : BlobStatGetter {
      method sizeBytes (line 98) | size_t sizeBytes(const Blob& blob) const override {

FILE: caffe2/core/tensor.h
  function namespace (line 44) | namespace caffe2 {
  function Shrink (line 277) | void Shrink(TIndex outer_dim) {
  function ResizeLike (line 331) | void ResizeLike(const Tensor<OtherContext>& src_tensor) {
  function Reshape (line 342) | inline void Reshape(const vector<TIndex>& dims) {
  function T (line 500) | const T* data() const {
  function T (line 594) | T* mutable_data() {
  function TIndex (line 629) | inline TIndex size_from_dim(int k) const {
  function TIndex (line 633) | inline TIndex size_to_dim(int k) const {
  function TIndex (line 637) | inline TIndex size_between_dim(int k, int l) const {
  function canonical_axis_index (line 652) | inline int canonical_axis_index(int axis_index) const {
  function dim32 (line 673) | inline int dim32(const int i) const {
  function TIndex (line 687) | inline TIndex dim(const int i) const {
  function SetDims (line 721) | bool SetDims() {
  function SetDims (line 731) | bool SetDims(const TIndex d0) {
  function SetDims (line 739) | bool SetDims(const TIndex d0, const TIndex d1) {
  function SetDims (line 748) | bool SetDims(const TIndex d0, const TIndex d1, const TIndex d2) {
  function SetDims (line 758) | bool
  type Tensor (line 776) | typedef Tensor<CPUContext> TensorCPU;
  type TypeMeta (line 781) | typedef TypeMeta (*TypeCall)(const void*);
  type vector (line 792) | typedef vector<TIndex> (*TensorInfoCall)(
  function class (line 814) | class TensorPrinter {

FILE: caffe2/core/timer.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/core/timer_test.cc
  type caffe2 (line 24) | namespace caffe2 {
    function TEST (line 27) | TEST(TimerTest, Test) {
    function TEST (line 51) | TEST(TimerTest, TestLatency) {

FILE: caffe2/core/transform.cc
  type caffe2 (line 25) | namespace caffe2 {
    function NetDef (line 191) | NetDef Transform::ApplyTo(const NetDef& orig_net) {
    function CreateTransform (line 199) | unique_ptr<Transform> CreateTransform(string key) {
    function NetDef (line 207) | NetDef ApplyTransform(const string& key, const NetDef& netdef) {
    function average_net_run_duration (line 212) | double average_net_run_duration(
    function NetDef (line 257) | NetDef ApplyTransformIfFaster(

FILE: caffe2/core/transform.h
  function namespace (line 25) | namespace caffe2 {

FILE: caffe2/core/transform_test.cc
  type caffe2 (line 23) | namespace caffe2 {
    class TransformDummyOp (line 31) | class TransformDummyOp final : public OperatorBase {
      method Run (line 34) | bool Run(int /* unused */) override {
    class DummyTransform (line 66) | class DummyTransform : public Transform {
      method PatternRule (line 69) | bool PatternRule(const Graph& g, const std::vector<int>& subgraph, i...
      method ValidatorRule (line 94) | bool ValidatorRule(const Graph& g, const std::vector<int>& subgraph)
      method ReplaceRule (line 107) | bool ReplaceRule(const std::vector<int>& match, Graph* g_ptr) overri...
    function TEST (line 154) | TEST(TransformTest, TestPatternMatch) {
    function TEST (line 175) | TEST(TransformTest, TestReplacePattern) {
    function TEST (line 211) | TEST(TransformTest, TestTransformApply) {
    class SortedDummyTransform (line 236) | class SortedDummyTransform : public Transform {
      method SortedDummyTransform (line 238) | SortedDummyTransform() {
      method PatternRule (line 241) | bool PatternRule(const Graph& g, const std::vector<int>& subgraph, i...
      method ValidatorRule (line 248) | bool ValidatorRule(const Graph& g, const std::vector<int>& subgraph)
      method ReplaceRule (line 258) | bool ReplaceRule(const std::vector<int>& match, Graph* g_ptr) overri...
    function TEST (line 269) | TEST(TransformTest, TestPatternMatchTypeSortedOrder) {
    class GeneralDummyTransform (line 293) | class GeneralDummyTransform : public Transform {
      method GeneralDummyTransform (line 295) | GeneralDummyTransform() {
      method PatternRule (line 298) | bool PatternRule(const Graph& g, const std::vector<int>& subgraph, i...
      method ValidatorRule (line 308) | bool ValidatorRule(const Graph& g, const std::vector<int>& subgraph)
      method ReplaceRule (line 318) | bool ReplaceRule(const std::vector<int>& match, Graph* g_ptr) overri...
    function TEST (line 329) | TEST(TransformTest, TestPatternMatchTypeGeneral) {
    class TransformSleepFastOp (line 347) | class TransformSleepFastOp final : public OperatorBase {
      method Run (line 350) | bool Run(int /* unused */) override {
    class TransformSleepSlowOp (line 363) | class TransformSleepSlowOp final : public OperatorBase {
      method Run (line 366) | bool Run(int /* unused */) override {
    class TypeSwapTransform (line 383) | class TypeSwapTransform : public Transform {
      method TypeSwapTransform (line 386) | explicit TypeSwapTransform(string old_type, string new_type)
      method PatternRule (line 390) | bool PatternRule(const Graph& g, const std::vector<int>& subgraph, i...
      method ValidatorRule (line 398) | bool ValidatorRule(const Graph& g, const std::vector<int>& subgraph)
      method ReplaceRule (line 408) | bool ReplaceRule(const std::vector<int>& match, Graph* g_ptr) overri...
    class FastToSlowTransform (line 420) | class FastToSlowTransform : public TypeSwapTransform {
      method FastToSlowTransform (line 422) | explicit FastToSlowTransform()
    class SlowToFastTransform (line 428) | class SlowToFastTransform : public TypeSwapTransform {
      method SlowToFastTransform (line 430) | explicit SlowToFastTransform()
    function TEST (line 436) | TEST(TransformTest, TestApplyTransformIfFasterIsFaster) {
    function TEST (line 455) | TEST(TransformTest, TestApplyTransformIfFasterButSlower) {

FILE: caffe2/core/typeid.cc
  type caffe2 (line 24) | namespace caffe2 {
    function string (line 42) | string Demangle(const char* name) {
    function string (line 46) | string Demangle(const char* name) {
    function string (line 57) | string GetExceptionString(const std::exception& e) {
    type UninitializedTypeNameRegisterer (line 69) | struct UninitializedTypeNameRegisterer {
      method UninitializedTypeNameRegisterer (line 70) | UninitializedTypeNameRegisterer() {

FILE: caffe2/core/typeid.h
  function namespace (line 35) | namespace caffe2 {
  function class (line 104) | class TypeMeta {
  function m (line 188) | inline bool operator==(const TypeMeta& m) const {
  function m (line 191) | inline bool operator!=(const TypeMeta& m) const {
  function ItemSize (line 216) | size_t ItemSize() {
  function _Ctor (line 236) | void _Ctor(void* ptr, size_t n) {
  function _Copy (line 247) | void _Copy(const void* src, void* dst, size_t n) {
  function _CopyNotAllowed (line 259) | void
  function _Dtor (line 270) | void _Dtor(void* ptr, size_t n) {
  function TypeMeta (line 293) | TypeMeta Make() {

FILE: caffe2/core/typeid_test.cc
  type caffe2 (line 21) | namespace caffe2 {
    class TypeMetaTestFoo (line 24) | class TypeMetaTestFoo {}
    class TypeMetaTestBar (line 25) | class TypeMetaTestBar {}
    function TEST (line 33) | TEST(TypeMetaTest, TypeMetaStatic) {
    function TEST (line 45) | TEST(TypeMetaTest, Names) {
    function TEST (line 60) | TEST(TypeMetaTest, TypeMeta) {
    class ClassAllowAssignment (line 99) | class ClassAllowAssignment {
      method ClassAllowAssignment (line 101) | ClassAllowAssignment() : x(42) {}
      method ClassAllowAssignment (line 102) | ClassAllowAssignment(const ClassAllowAssignment& src) : x(src.x) {}
      method ClassAllowAssignment (line 103) | ClassAllowAssignment& operator=(const ClassAllowAssignment& src) = d...
    class ClassNoAssignment (line 107) | class ClassNoAssignment {
      method ClassNoAssignment (line 109) | ClassNoAssignment() : x(42) {}
      method ClassNoAssignment (line 110) | ClassNoAssignment(const ClassNoAssignment& src) = delete;
      method ClassNoAssignment (line 111) | ClassNoAssignment& operator=(const ClassNoAssignment& src) = delete;
    function TEST (line 121) | TEST(TypeMetaTest, CtorDtorAndCopy) {
    function TEST (line 151) | TEST(TypeMetaTest, Float16IsNotUint16) {

FILE: caffe2/core/types.cc
  type caffe2 (line 25) | namespace caffe2 {
    function TypeMetaToDataType (line 52) | TensorProto::DataType TypeMetaToDataType(const TypeMeta& meta) {
    function TypeMeta (line 77) | const TypeMeta& DataTypeToTypeMeta(const TensorProto::DataType& dt) {

FILE: caffe2/core/types.h
  function namespace (line 29) | namespace caffe2 {
  function namespace (line 68) | namespace caffe2 {
  function namespace (line 88) | namespace std {

FILE: caffe2/core/workspace.cc
  type caffe2 (line 35) | namespace caffe2 {
    function Blob (line 120) | Blob* Workspace::CreateBlob(const string& name) {
    function Blob (line 134) | Blob* Workspace::CreateLocalBlob(const string& name) {
    function Blob (line 144) | Blob* Workspace::RenameBlob(const string& old_name, const string& new_...
    function Blob (line 180) | const Blob* Workspace::GetBlob(const string& name) const {
    function Blob (line 230) | Blob* Workspace::GetBlob(const string& name) {
    function NetBase (line 234) | NetBase* Workspace::CreateNet(const NetDef& net_def, bool overwrite) {
    function NetBase (line 239) | NetBase* Workspace::CreateNet(
    function NetBase (line 271) | NetBase* Workspace::GetNet(const string& name) {
    function ThreadPool (line 323) | ThreadPool* Workspace::GetThreadPool() {

FILE: caffe2/core/workspace.h
  function namespace (line 39) | namespace caffe2 {
  function class (line 63) | class Workspace {
  function string (line 183) | const string& RootFolder() { return root_folder_; }
  function HasBlob (line 187) | inline bool HasBlob(const string& name) const {

FILE: caffe2/core/workspace_test.cc
  type caffe2 (line 23) | namespace caffe2 {
    class WorkspaceTestFoo (line 25) | class WorkspaceTestFoo {}
    function TEST (line 29) | TEST(WorkspaceTest, BlobAccess) {
    function TEST (line 73) | TEST(WorkspaceTest, RunEmptyPlan) {
    function TEST (line 79) | TEST(WorkspaceTest, Sharing) {
    function TEST (line 111) | TEST(WorkspaceTest, BlobMapping) {

FILE: caffe2/cuda_rtc/common_rtc.h
  function namespace (line 35) | namespace caffe2 {
  function std (line 121) | inline std::string GetUniqueName() {

FILE: caffe2/cuda_rtc/elemenntwise_rtc_gpu.cc
  type caffe2 (line 22) | namespace caffe2 {
    class ElementwiseRTCFunction (line 24) | class ElementwiseRTCFunction
      method ElementwiseRTCFunction (line 27) | ElementwiseRTCFunction() : CudaRTCFunction(), name_(GetUniqueName()) {}
      method string (line 30) | string KernelName(Args... /*args*/) {
    function string (line 42) | string ElementwiseRTCFunction::GetSource(
    class ElementwiseRTCOp (line 90) | class ElementwiseRTCOp final : public Operator<CUDAContext> {
      method ElementwiseRTCOp (line 92) | ElementwiseRTCOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDevice (line 101) | bool RunOnDevice() override {

FILE: caffe2/cuda_rtc/pool_op_rtc_gpu.cc
  type caffe2 (line 24) | namespace caffe2 {
    class AveragePool (line 26) | class AveragePool {}
    class MaxPool (line 27) | class MaxPool {}
    class MaxPoolRTCFunction (line 118) | class MaxPoolRTCFunction : public CudaRTCFunction<MaxPoolRTCFunction> {
      method MaxPoolRTCFunction (line 120) | MaxPoolRTCFunction() : CudaRTCFunction(), name_(GetUniqueName()) {}
      method string (line 123) | string KernelName(Args... /*args*/) {
    class MaxPoolGradientRTCFunction (line 134) | class MaxPoolGradientRTCFunction
      method MaxPoolGradientRTCFunction (line 137) | MaxPoolGradientRTCFunction() : CudaRTCFunction(), name_(GetUniqueNam...
      method string (line 140) | string KernelName(Args... /*args*/) {
    function string (line 153) | string MaxPoolRTCFunction::GetSource(
    function string (line 177) | string MaxPoolGradientRTCFunction::GetSource(
    class MaxPoolRTCOp (line 204) | class MaxPoolRTCOp final : public ConvPoolOpBase<CUDAContext> {
      method MaxPoolRTCOp (line 206) | MaxPoolRTCOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDeviceWithOrderNCHW (line 213) | bool RunOnDeviceWithOrderNCHW() override {
      method RunOnDeviceWithOrderNHWC (line 244) | bool RunOnDeviceWithOrderNHWC() override {
    class MaxPoolGradientRTCOp (line 254) | class MaxPoolGradientRTCOp final : public ConvPoolOpBase<CUDAContext> {
      method MaxPoolGradientRTCOp (line 256) | MaxPoolGradientRTCOp(const OperatorDef& operator_def, Workspace* ws)
      method RunOnDeviceWithOrderNCHW (line 263) | bool RunOnDeviceWithOrderNCHW() override {
      method RunOnDeviceWithOrderNHWC (line 297) | bool RunOnDeviceWithOrderNHWC() override {

FILE: caffe2/db/create_db_op.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/db/create_db_op.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/db/create_db_op_gpu.cc
  type caffe2 (line 20) | namespace caffe2 {

FILE: caffe2/db/db_test.cc
  type caffe2 (line 28) | namespace caffe2 {
    type db (line 29) | namespace db {
      function CreateAndFill (line 33) | static bool CreateAndFill(const string& db_type, const string& name) {
      function TestCursor (line 52) | static void TestCursor(Cursor* cursor) {
      function DBSeekTestWrapper (line 81) | static void DBSeekTestWrapper(const string& db_type) {
      function TEST (line 93) | TEST(DBSeekTest, RocksDB) {
      function TEST (line 97) | TEST(DBSeekTest, LevelDB) {
      function TEST (line 101) | TEST(DBSeekTest, LMDB) {
      function TEST (line 105) | TEST(DBReaderTest, Reader) {
      function TEST (line 170) | TEST(DBReaderShardedTest, Reader) {

FILE: caffe2/db/leveldb.cc
  type caffe2 (line 26) | namespace caffe2 {
    type db (line 27) | namespace db {
      class LevelDBCursor (line 29) | class LevelDBCursor : public Cursor {
        method LevelDBCursor (line 31) | explicit LevelDBCursor(leveldb::DB* db)
        method Seek (line 36) | void Seek(const string& key) override { iter_->Seek(key); }
        method SupportsSeek (line 37) | bool SupportsSeek() override { return true; }
        method SeekToFirst (line 38) | void SeekToFirst() override { iter_->SeekToFirst(); }
        method Next (line 39) | void Next() override { iter_->Next(); }
        method string (line 40) | string key() override { return iter_->key().ToString(); }
        method string (line 41) | string value() override { return iter_->value().ToString(); }
        method Valid (line 42) | bool Valid() override { return iter_->Valid(); }
      class LevelDBTransaction (line 48) | class LevelDBTransaction : public Transaction {
        method LevelDBTransaction (line 50) | explicit LevelDBTransaction(leveldb::DB* db) : db_(db) {
        method Put (line 55) | void Put(const string& key, const string& value) override {
        method Commit (line 58) | void Commit() override {
      class LevelDB (line 73) | class LevelDB : public DB {
        method LevelDB (line 75) | LevelDB(const string& source, Mode mode) : DB(source, mode) {
        method Close (line 91) | void Close() override { db_.reset(); }
        method NewCursor (line 92) | unique_ptr<Cursor> NewCursor() override {
        method NewTransaction (line 95) | unique_ptr<Transaction> NewTransaction() override {

FILE: caffe2/db/lmdb.cc
  type caffe2 (line 30) | namespace caffe2 {
    type db (line 31) | namespace db {
      function MDB_CHECK (line 35) | inline void MDB_CHECK(int mdb_status) {
      class LMDBCursor (line 39) | class LMDBCursor : public Cursor {
        method LMDBCursor (line 41) | explicit LMDBCursor(MDB_env* mdb_env)
        method Seek (line 54) | void Seek(const string& key) override {
        method SupportsSeek (line 72) | bool SupportsSeek() override { return true; }
        method SeekToFirst (line 74) | void SeekToFirst() override { SeekLMDB(MDB_FIRST); }
        method Next (line 76) | void Next() override { SeekLMDB(MDB_NEXT); }
        method string (line 78) | string key() override {
        method string (line 82) | string value() override {
        method Valid (line 87) | bool Valid() override { return valid_; }
        method SeekLMDB (line 90) | void SeekLMDB(MDB_cursor_op op) {
      class LMDBTransaction (line 108) | class LMDBTransaction final : public Transaction {
        method LMDBTransaction (line 110) | explicit LMDBTransaction(MDB_env* mdb_env)
        method Commit (line 120) | void Commit() override {
      class LMDB (line 136) | class LMDB : public DB {
        method Close (line 140) | void Close() override {
        method NewCursor (line 146) | unique_ptr<Cursor> NewCursor() override {
        method NewTransaction (line 149) | unique_ptr<Transaction> NewTransaction() override {

FILE: caffe2/db/protodb.cc
  type caffe2 (line 23) | namespace caffe2 {
    type db (line 24) | namespace db {
      class ProtoDBCursor (line 26) | class ProtoDBCursor : public Cursor {
        method ProtoDBCursor (line 28) | explicit ProtoDBCursor(const TensorProtos* proto)
        method Seek (line 32) | void Seek(const string& /*str*/) override {
        method SeekToFirst (line 36) | void SeekToFirst() override { iter_ = 0; }
        method Next (line 37) | void Next() override { ++iter_; }
        method string (line 38) | string key() override { return proto_->protos(iter_).name(); }
        method string (line 39) | string value() override { return proto_->protos(iter_).SerializeAs...
        method Valid (line 40) | bool Valid() override { return iter_ < proto_->protos_size(); }
      class ProtoDBTransaction (line 47) | class ProtoDBTransaction : public Transaction {
        method ProtoDBTransaction (line 49) | explicit ProtoDBTransaction(TensorProtos* proto)
        method Put (line 56) | void Put(const string& key, const string& value) override {
        method Commit (line 73) | void Commit() override {}
      class ProtoDB (line 82) | class ProtoDB : public DB {
        method ProtoDB (line 84) | ProtoDB(const string& source, Mode mode)
        method Close (line 95) | void Close() override {
        method NewCursor (line 101) | unique_ptr<Cursor> NewCursor() override {
        method NewTransaction (line 104) | unique_ptr<Transaction> NewTransaction() override {

FILE: caffe2/db/zmqdb.cc
  type caffe2 (line 26) | namespace caffe2 {
    type db (line 27) | namespace db {
      class ZmqDBCursor (line 29) | class ZmqDBCursor : public Cursor {
        method ZmqDBCursor (line 31) | explicit ZmqDBCursor(const string& source)
        method Seek (line 51) | void Seek(const string& /*key*/) override { /* do nothing */
        method SeekToFirst (line 54) | void SeekToFirst() override { /* do nothing */ }
        method Next (line 56) | void Next() override {
        method string (line 65) | string key() override { return key_; }
        method string (line 66) | string value() override { return value_; }
        method Valid (line 67) | bool Valid() override { return true; }
        method Prefetch (line 71) | void Prefetch() {
      class ZmqDB (line 103) | class ZmqDB : public DB {
        method ZmqDB (line 105) | ZmqDB(const string& source, Mode mode)
        method Close (line 112) | void Close() override {}
        method NewCursor (line 114) | unique_ptr<Cursor> NewCursor() override {
        method NewTransaction (line 118) | unique_ptr<Transaction> NewTransaction() override {

FILE: caffe2/distributed/file_store_handler.cc
  type caffe2 (line 37) | namespace caffe2 {
    function encodeName (line 39) | static std::string encodeName(const std::string& name) {

FILE: caffe2/distributed/file_store_handler.h
  function namespace (line 21) | namespace caffe2 {

FILE: caffe2/distributed/file_store_handler_op.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/distributed/file_store_handler_op.h
  function namespace (line 23) | namespace caffe2 {

FILE: caffe2/distributed/file_store_handler_op_gpu.cc
  type caffe2 (line 21) | namespace caffe2 {

FILE: caffe2/distributed/file_store_handler_op_test.py
  class TestFileStoreHandlerOp (line 35) | class TestFileStoreHandlerOp(TestCase):
    method setUp (line 38) | def setUp(self):
    method tearDown (line 45) | def tearDown(self):
    method create_store_handler (line 49) | def create_store_handler(self):
    method test_set_get (line 72) | def test_set_get(self):
    method test_get_timeout (line 75) | def test_get_timeout(self):

FILE: caffe2/distributed/py_export.cc
  type caffe2 (line 5) | namespace caffe2 {
    type python (line 6) | namespace python {
      function PYBIND11_MODULE (line 10) | PYBIND11_MODULE(python, m) {

FILE: caffe2/distributed/redis_store_handler.cc
  type caffe2 (line 25) | namespace caffe2 {
    type timeval (line 32) | struct timeval

FILE: caffe2/distributed/redis_store_handler.h
  function namespace (line 27) | namespace caffe2 {

FILE: caffe2/distributed/redis_store_handler_op.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/distributed/redis_store_handler_op.h
  function namespace (line 25) | namespace caffe2 {

FILE: caffe2/distributed/redis_store_handler_op_gpu.cc
  type caffe2 (line 21) | namespace caffe2 {

FILE: caffe2/distributed/redis_store_handler_op_test.py
  class TestRedisStoreHandlerOp (line 33) | class TestRedisStoreHandlerOp(TestCase):
    method setUp (line 34) | def setUp(self):
    method tearDown (line 38) | def tearDown(self):
    method create_store_handler (line 41) | def create_store_handler(self):
    method test_set_get (line 53) | def test_set_get(self):
    method test_get_timeout (line 56) | def test_get_timeout(self):

FILE: caffe2/distributed/store_handler.cc
  type caffe2 (line 23) | namespace caffe2 {

FILE: caffe2/distributed/store_handler.h
  function namespace (line 25) | namespace caffe2 {

FILE: caffe2/distributed/store_ops.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/distributed/store_ops.h
  function namespace (line 23) | namespace caffe2 {

FILE: caffe2/distributed/store_ops_test_util.py
  class StoreOpsTests (line 30) | class StoreOpsTests(object):
    method _test_set_get (line 32) | def _test_set_get(cls, queue, create_store_handler_fn, index, num_procs):
    method test_set_get (line 64) | def test_set_get(cls, create_store_handler_fn):
    method test_get_timeout (line 87) | def test_get_timeout(cls, create_store_handler_fn):

FILE: caffe2/experiments/operators/fully_connected_op_decomposition.cc
  type caffe2 (line 19) | namespace caffe2 {
    class GetFCDecompGradient (line 28) | class GetFCDecompGradient : public GradientMakerBase {
      method GetGradientDefs (line 30) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/experiments/operators/fully_connected_op_decomposition.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/experiments/operators/fully_connected_op_decomposition_gpu.cc
  type caffe2 (line 20) | namespace caffe2 {

FILE: caffe2/experiments/operators/fully_connected_op_prune.cc
  type caffe2 (line 19) | namespace caffe2 {
    class GetFCPruneGradient (line 32) | class GetFCPruneGradient : public GradientMakerBase {
      method GetGradientDefs (line 34) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/experiments/operators/fully_connected_op_prune.h
  function namespace (line 24) | namespace caffe2 {
  function RunOnDevice (line 133) | bool RunOnDevice() override {
  function RunOnDevice (line 206) | bool RunOnDevice() override {

FILE: caffe2/experiments/operators/fully_connected_op_sparse.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/experiments/operators/fully_connected_op_sparse.h
  function namespace (line 27) | namespace caffe2 {
  function RunOnDevice (line 102) | bool RunOnDevice() override {

FILE: caffe2/experiments/operators/funhash_op.cc
  type caffe2 (line 19) | namespace caffe2 {
    class GetFunHashGradient (line 64) | class GetFunHashGradient : public GradientMakerBase {
      method GetGradientDefs (line 66) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/experiments/operators/funhash_op.h
  function namespace (line 31) | namespace caffe2 {

FILE: caffe2/experiments/operators/sparse_funhash_op.cc
  type caffe2 (line 19) | namespace caffe2 {
    class GetSparseFunHashGradient (line 70) | class GetSparseFunHashGradient : public GradientMakerBase {
      method GetGradientDefs (line 72) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/experiments/operators/sparse_funhash_op.h
  function namespace (line 30) | namespace caffe2 {

FILE: caffe2/experiments/operators/sparse_matrix_reshape_op.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/experiments/operators/sparse_matrix_reshape_op.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/experiments/operators/tt_contraction_op.cc
  type caffe2 (line 19) | namespace caffe2 {
    class GetTTContractionGradient (line 42) | class GetTTContractionGradient : public GradientMakerBase {
      method GetGradientDefs (line 44) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/experiments/operators/tt_contraction_op.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/experiments/operators/tt_contraction_op_gpu.cc
  type caffe2 (line 20) | namespace caffe2 {

FILE: caffe2/experiments/operators/tt_pad_op.cc
  type caffe2 (line 19) | namespace caffe2 {
    class GetTTPadGradient (line 31) | class GetTTPadGradient : public GradientMakerBase {
      method GetGradientDefs (line 33) | vector<OperatorDef> GetGradientDefs() override {

FILE: caffe2/experiments/operators/tt_pad_op.h
  function namespace (line 24) | namespace caffe2 {

FILE: caffe2/experiments/python/SparseTransformer.py
  class NetDefNode (line 26) | class NetDefNode():
    method __init__ (line 28) | def __init__(self, name, optype, p=None, op=None):
    method insertInput (line 37) | def insertInput(self, p):
    method deleteInput (line 51) | def deleteInput(self, p):
  function maskNallocate (line 57) | def maskNallocate(weight_name):
  function transFCRelu (line 73) | def transFCRelu(cur, id2node, name2id, ops, model):
  function Prune2Sparse (line 145) | def Prune2Sparse(cur, id2node, name2id, ops, model):
  function net2list (line 156) | def net2list(net_root):
  function netbuilder (line 175) | def netbuilder(model):

FILE: caffe2/experiments/python/convnet_benchmarks.py
  function MLP (line 90) | def MLP(order):
  function AlexNet (line 115) | def AlexNet(order):
  function OverFeat (line 196) | def OverFeat(order):
  function VGGA (line 268) | def VGGA(order):
  function net_DAG_Builder (line 383) | def net_DAG_Builder(model):
  function _InceptionModule (line 391) | def _InceptionModule(
  function Inception (line 454) | def Inception(order):
  function AddInput (line 529) | def AddInput(model, batch_size, db, db_type):
  function AddParameterUpdate (line 542) | def AddParameterUpdate(model):
  function Benchmark (line 553) | def Benchmark(model_gen, arg):
  function GetArgumentParser (line 626) | def GetArgumentParser():

FILE: caffe2/experiments/python/device_reduce_sum_bench.py
  class BenchmarkMeta (line 41) | class BenchmarkMeta(type):
    method __new__ (line 42) | def __new__(metacls, name, bases, class_dict):
  class Benchmark (line 50) | class Benchmark(object):
    method __init__ (line 52) | def __init__(self):
    method display (line 55) | def display(self):
  class SumElements (line 63) | class SumElements(Benchmark):
    method run (line 64) | def run(self):
  class SumSqrElements (line 78) | class SumSqrElements(Benchmark):
    method run (line 79) | def run(self):
  class SoftMaxWithLoss (line 93) | class SoftMaxWithLoss(Benchmark):
    method run (line 94) | def run(self):
  function parse_args (line 110) | def parse_args():
  function main (line 118) | def main():

FILE: caffe2/experiments/python/funhash_op_test.py
  class TestFunHash (line 31) | class TestFunHash(hu.HypothesisTestCase):
    method test_funhash (line 39) | def test_funhash(self, n_out, n_in, n_data, n_weight, n_alpha, sparsity,

FILE: caffe2/experiments/python/net_construct_bench.py
  function AddMomentumParameterUpdate (line 43) | def AddMomentumParameterUpdate(train_model, LR):
  function Create (line 77) | def Create(args):
  function main (line 136) | def main():

FILE: caffe2/experiments/python/sparse_funhash_op_test.py
  class TestFunHash (line 31) | class TestFunHash(hu.HypothesisTestCase):
    method test_funhash (line 39) | def test_funhash(self, n_out, n_in, n_data, n_weight, n_alpha, sparsity,

FILE: caffe2/experiments/python/sparse_reshape_op_test.py
  function test_reshape (line 28) | def test_reshape(old_shape, new_shape, stride_only=False):
  class TestSparseMatrixReshapeOp (line 63) | class TestSparseMatrixReshapeOp(TestCase):
    method test_basic_reshape (line 64) | def test_basic_reshape(self):
    method test_missing_dim (line 67) | def test_missing_dim(self):
    method test_stride_only (line 70) | def test_stride_only(self):
    method test_sparse_reshape_mm (line 73) | def test_sparse_reshape_mm(self):

FILE: caffe2/experiments/python/tt_contraction_op_test.py
  class TestTTContraction (line 30) | class TestTTContraction(hu.HypothesisTestCase):
    method test_tt_contraction (line 36) | def test_tt_contraction(self, D, K, M, N, gc, dc):

FILE: caffe2/experiments/python/tt_pad_op_test.py
  class TestTTPad (line 30) | class TestTTPad(hu.HypothesisTestCase):
    method test_tt_pad (line 35) | def test_tt_pad(self, K, M, N, gc, dc):

FILE: caffe2/image/image_input_op.cc
  type caffe2 (line 19) | namespace caffe2 {

FILE: caffe2/image/image_input_op.h
  function namespace (line 34) | namespace caffe2 {

FILE: caffe2/image/image_input_op_gpu.cc
  type caffe2 (line 21) | namespace caffe2 {

FILE: caffe2/image/transform_gpu.h
  function namespace (line 47) | namespace caffe2 {

FILE: caffe2/mkl/mkl_operator.cc
  type caffe2 (line 26) | namespace caffe2 {

FILE: caffe2/mkl/mkl_utils_test.cc
  type caffe2 (line 28) | namespace caffe2 {
    type mkl (line 29) | namespace mkl {
      function TEST (line 31) | TEST(MKLDNNTest, SimpleConvolutionTest) {
      function TEST (line 104) | TEST(MKLDNNTest, MKLMemoryCopyTest) {

FILE: caffe2/mkl/mklmemory_serialization.cc
  type caffe2 (line 23) | namespace caffe2 {
    type mkl (line 24) | namespace mkl {
      class MKLMemorySerializer (line 31) | class MKLMemorySerializer : public BlobSerializerBase {
        method MKLMemorySerializer (line 33) | MKLMemorySerializer() {}
        method Serialize (line 36) | void Serialize(
      class MKLMemoryDeserializer (line 93) | class MKLMemoryDeserializer : public BlobDeserializerBase {
        method Deserialize (line 95) | void Deserialize(const BlobProto& blob_proto, Blob* blob) override {

FILE: caffe2/mkl/mklmemory_serialization_test.cc
  type caffe2 (line 26) | namespace caffe2 {
    function TEST (line 30) | TEST(MKLTest, MKLMemorySerialization) {

FILE: caffe2/mkl/operators/concat_op.cc
  type caffe2 (line 21) | namespace caffe2 {
    type mkl (line 22) | namespace mkl {
      class MKLConcatOp (line 25) | class MKLConcatOp final : public MKLOperator<T> {
        method MKLConcatOp (line 29) | MKLConcatOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDevice (line 55) | bool RunOnDevice() override {

FILE: caffe2/mkl/operators/conv_op.cc
  type caffe2 (line 24) | namespace caffe2 {
    type mkl (line 25) | namespace mkl {
      class MKLConvOp (line 28) | class MKLConvOp final : public ConvPoolOpBase<MKLContext> {
        method MKLConvOp (line 31) | MKLConvOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDeviceWithOrderNCHW (line 44) | bool RunOnDeviceWithOrderNCHW() override {
        method RunOnDeviceWithOrderNHWC (line 179) | bool RunOnDeviceWithOrderNHWC() override {

FILE: caffe2/mkl/operators/conv_op_mkldnn.cc
  type caffe2 (line 24) | namespace caffe2 {
    type mkl (line 25) | namespace mkl {
      class ConvMKLDNNOp (line 28) | class ConvMKLDNNOp final : public ConvPoolOpBase<CPUContext> {
        method ConvMKLDNNOp (line 31) | ConvMKLDNNOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDeviceWithOrderNCHW (line 43) | bool RunOnDeviceWithOrderNCHW() override {
        method RunOnDeviceWithOrderNHWC (line 118) | bool RunOnDeviceWithOrderNHWC() override {

FILE: caffe2/mkl/operators/elementwise_sum_op.cc
  type caffe2 (line 23) | namespace caffe2 {
    type mkl (line 24) | namespace mkl {
      class MKLSumOp (line 27) | class MKLSumOp final : public MKLOperator<T> {
        method MKLSumOp (line 31) | MKLSumOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDevice (line 40) | bool RunOnDevice() override {

FILE: caffe2/mkl/operators/fully_connected_op.cc
  type caffe2 (line 23) | namespace caffe2 {
    type mkl (line 24) | namespace mkl {
      class MKLFullyConnectedOp (line 27) | class MKLFullyConnectedOp final : public MKLOperator<T> {
        method MKLFullyConnectedOp (line 29) | MKLFullyConnectedOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDevice (line 34) | bool RunOnDevice() override {

FILE: caffe2/mkl/operators/local_response_normalization_op.cc
  type caffe2 (line 25) | namespace caffe2 {
    type mkl (line 26) | namespace mkl {
      class MKLLRNOp (line 29) | class MKLLRNOp final : public LRNOpBase<T, MKLContext> {
        method MKLLRNOp (line 31) | MKLLRNOp(const OperatorDef& operator_def, Workspace* ws)

FILE: caffe2/mkl/operators/operator_fallback_mkl.cc
  type caffe2 (line 32) | namespace caffe2 {
    type SigmoidCPUFunctor (line 34) | struct SigmoidCPUFunctor {
  type caffe2 (line 46) | namespace caffe2 {
    type SigmoidCPUFunctor (line 34) | struct SigmoidCPUFunctor {

FILE: caffe2/mkl/operators/operator_fallback_mkl.h
  function namespace (line 27) | namespace caffe2 {

FILE: caffe2/mkl/operators/packed_fc_op.cc
  type caffe2 (line 27) | namespace caffe2 {
    type mkl (line 31) | namespace mkl {
      class PackedFCOp (line 33) | class PackedFCOp final : public Operator<CPUContext> {
        method PackedFCOp (line 36) | PackedFCOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDevice (line 55) | bool RunOnDevice() override {
        method Hash (line 150) | uint32_t Hash(const float* ptr, size_t n) {

FILE: caffe2/mkl/operators/pool_op.cc
  type caffe2 (line 25) | namespace caffe2 {
    type mkl (line 27) | namespace mkl {
      class MKLPoolOp (line 30) | class MKLPoolOp final : public ConvPoolOpBase<MKLContext> {
        method MKLPoolOp (line 33) | MKLPoolOp(const OperatorDef& operator_def, Workspace* ws)

FILE: caffe2/mkl/operators/relu_op.cc
  type caffe2 (line 24) | namespace caffe2 {
    type mkl (line 25) | namespace mkl {
      class MKLReluOp (line 28) | class MKLReluOp : public MKLOperator<T> {
        method RunOnDevice (line 32) | bool RunOnDevice() override {
      class MKLReluGradientOp (line 66) | class MKLReluGradientOp : public MKLOperator<T> {
        method RunOnDevice (line 70) | bool RunOnDevice() override {

FILE: caffe2/mkl/operators/spatial_batch_norm_op.cc
  type caffe2 (line 24) | namespace caffe2 {
    type mkl (line 25) | namespace mkl {
      class MKLBNOp (line 28) | class MKLBNOp final : public SpatialBNOp<MKLContext> {
        method MKLBNOp (line 30) | MKLBNOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDevice (line 39) | bool RunOnDevice() {

FILE: caffe2/mkl/operators/squeeze_op.cc
  type caffe2 (line 22) | namespace caffe2 {
    type mkl (line 23) | namespace mkl {
      class MKLSqueezeOp (line 26) | class MKLSqueezeOp final : public MKLOperator<T> {
        method MKLSqueezeOp (line 30) | MKLSqueezeOp(const OperatorDef& operator_def, Workspace* ws)
        method RunOnDevice (line 44) | bool RunOnDevice() override {

FILE: caffe2/mkl/operators/utility_ops.cc
  type caffe2 (line 22) | namespace caffe2 {
    type mkl (line 23) | namespace mkl {
      class CopyCPUToMKLOp (line 25) | class CopyCPUToMKLOp final : public MKLOperator<float> {
        method RunOnDevice (line 28) | bool RunOnDevice() override {
      class CopyMKLToCPUOp (line 40) | class CopyMKLToCPUOp final : public MKLOperator<float> {
        method RunOnDevice (line 44) | bool RunOnDevice() override {

FILE: caffe2/mkl/utils/mkl_context.cc
  type caffe2 (line 21) | namespace caffe2 {

FILE: caffe2/mkl/utils/mkl_context.h
  function namespace (line 26) | namespace caffe2 {

FILE: caffe2/mkl/utils/mkl_dnn_cppwrapper.h
  function namespace (line 33) | namespace caffe2 {

FILE: caffe2/mkl/utils/mkl_memory.cc
  type caffe2 (line 32) | namespace caffe2 {
    function GetMKLTensorInfo (line 38) | static vector<TIndex> GetMKLTensorInfo(
    function TypeMeta (line 53) | static TypeMeta GetMKLTensorType(const void*) {
    function RegisterForType (line 58) | static void RegisterForType() {
    function Caffe2InitializeMKL (line 65) | static bool Caffe2InitializeMKL(int*, char***) {

FILE: caffe2/mkl/utils/mkl_memory.h
  function namespace (line 34) | namespace caffe2 {
  function Reset (line 268) | void Reset() {
  function CopyFrom (line 316) | void CopyFrom(const void* ptr) {
  function CopyFrom (line 329) | void CopyFrom(const TensorCPU& tensor) {
  function CopyFrom (line 337) | void CopyFrom(const MKLMemory<T>& other) {
  function ShareFromRaw (line 355) | bool ShareFromRaw(const void* ptr) {
  function ShareFromTensor (line 364) | bool ShareFromTensor(const TensorCPU& tensor) {
  function ShareFrom (line 372) | bool ShareFrom(const MKLMemory<T>& other) {
  function CopyTo (line 387) | void CopyTo(void* ptr) const {
  function CopyTo (line 400) | void CopyTo(TensorCPU* tensor) const {
  function dim32 (line 481) | inline int dim32(const int i) const {
  function TIndex (line 498) | inline TIndex dim(const int i) const {
  function T (line 588) | T* buffer() {

FILE: caffe2/mkl/utils/mkl_operator.h
  function namespace (line 27) | namespace caffe2 {

FILE: caffe2/mkl/utils/sgemm_pack.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/core/context.cc
  type caffe2 (line 8) | namespace caffe2 {
    function EventCreateOPENGL (line 25) | void EventCreateOPENGL(const DeviceOption & /* unused */,
    function EventRecordOPENGL (line 27) | void EventRecordOPENGL(Event * /* unused */, const void * /* unused */,
    function EventWaitOPENGLOPENGL (line 29) | void EventWaitOPENGLOPENGL(const Event * /* unused */, void * /* unuse...
    function EventFinishOPENGL (line 30) | void EventFinishOPENGL(const Event * /* unused */) {}
    function EventResetOPENGL (line 31) | void EventResetOPENGL(Event * /* unused */) {}

FILE: caffe2/mobile/contrib/arm-compute/core/context.h
  function namespace (line 29) | namespace caffe2 {
  function lazy_allocate (line 151) | void lazy_allocate(const Blob *b, bool allocate_tensor, bool try_to_copy...
  function fillGLTensor (line 168) | void fillGLTensor(const Blob *b) const {
  function dim32 (line 234) | const int32_t dim32(const int index) const { return dims_.at(index); }
  function size (line 236) | const int32_t size() const {
  function T (line 246) | T *map() const {
  function SetDims (line 275) | bool SetDims() {
  function SetDims (line 282) | bool SetDims(const TIndex d0) {
  function SetDims (line 290) | bool SetDims(const TIndex d0, const TIndex d1) {
  function SetDims (line 299) | bool SetDims(const TIndex d0, const TIndex d1, const TIndex d2) {
  function SetDims (line 309) | bool SetDims(const TIndex d0, const TIndex d1, const TIndex d2,

FILE: caffe2/mobile/contrib/arm-compute/core/net_gl.cc
  type caffe2 (line 31) | namespace caffe2 {
    function PairLargerThan (line 97) | bool PairLargerThan(const std::pair<A, B>& x, const std::pair<A, B>& y) {

FILE: caffe2/mobile/contrib/arm-compute/core/net_gl.h
  function namespace (line 30) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/core/operator.cc
  type caffe2 (line 3) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/core/operator.h
  function namespace (line 7) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/core/rewrite_net.cc
  type caffe2 (line 23) | namespace caffe2 {
    type Analysis (line 25) | struct Analysis {
      type SSA (line 26) | struct SSA {
    function Analysis (line 35) | static Analysis analyzeNet(const NetDef& net) {
      type SSA (line 26) | struct SSA {
    function insertCopyFromGLOp (line 61) | static void insertCopyFromGLOp(NetDef& predictNet, const std::string& ...
    function NetDef (line 69) | static NetDef insertInputOutputCopyOps(const NetDef& def, std::unorder...
    function tryFuseAdjacentOps (line 153) | static bool tryFuseAdjacentOps(const OperatorDef& currentOp,
    function NetDef (line 186) | static NetDef runOpenGLFusion(const NetDef& def, std::unordered_set<st...
    function dumpDefForOpenGL (line 222) | void dumpDefForOpenGL(const NetDef& d) {
    function NetDef (line 242) | NetDef rewritePredictNetForOpenGL(const NetDef& predictNet, bool runFu...
    function tryConvertToOpenGL (line 264) | bool tryConvertToOpenGL(const NetDef& predictNet,

FILE: caffe2/mobile/contrib/arm-compute/core/rewrite_net.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/operators/activation_ops.cc
  type caffe2 (line 7) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/operators/activation_ops.h
  function namespace (line 7) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/operators/concat_op.cc
  type caffe2 (line 5) | namespace caffe2 {
    class GLConcatOp (line 7) | class GLConcatOp final : public Operator<GLContext> {
      method GLConcatOp (line 9) | GLConcatOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/conv_op.cc
  type caffe2 (line 8) | namespace caffe2 {
    class GLConvOp (line 11) | class GLConvOp final : public ConvPoolOpBase<GLContext> {
      method GLConvOp (line 14) | GLConvOp(const OperatorDef& operator_def, Workspace* ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/copy_op.cc
  type caffe2 (line 4) | namespace caffe2 {
    class CopyFromGLOp (line 6) | class CopyFromGLOp final : public Operator<GLContext> {
      method CopyFromGLOp (line 8) | CopyFromGLOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/elementwise_sum_op.cc
  type caffe2 (line 5) | namespace caffe2 {
    class GLSumOp (line 7) | class GLSumOp final : public Operator<GLContext> {
      method GLSumOp (line 9) | GLSumOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/fully_connected_op.cc
  type caffe2 (line 6) | namespace caffe2 {
    class GLFullyConnectedOp (line 8) | class GLFullyConnectedOp final : public Operator<GLContext> {
      method GLFullyConnectedOp (line 10) | GLFullyConnectedOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/norm_planar_yuv_op.cc
  type caffe2 (line 4) | namespace caffe2 {
    class GLNormalizePlanarYUVOp (line 7) | class GLNormalizePlanarYUVOp final : public Operator<GLContext> {
      method GLNormalizePlanarYUVOp (line 9) | GLNormalizePlanarYUVOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/pool_op.cc
  type caffe2 (line 5) | namespace caffe2 {
    class GLAveragePoolOp (line 8) | class GLAveragePoolOp final : public ConvPoolOpBase<GLContext> {
      method GLAveragePoolOp (line 11) | GLAveragePoolOp(const OperatorDef& operator_def, Workspace* ws)
    class GLMaxPoolOp (line 25) | class GLMaxPoolOp final : public ConvPoolOpBase<GLContext> {
      method GLMaxPoolOp (line 28) | GLMaxPoolOp(const OperatorDef& operator_def, Workspace* ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/reshape_op.cc
  type caffe2 (line 5) | namespace caffe2 {
    class GLReshapeOp (line 7) | class GLReshapeOp final : public Operator<GLContext> {
      method GLReshapeOp (line 9) | GLReshapeOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/resize_op.cc
  type caffe2 (line 5) | namespace caffe2 {
    class GLResizeNearestOp (line 8) | class GLResizeNearestOp final : public Operator<GLContext> {
      method GLResizeNearestOp (line 10) | GLResizeNearestOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/softmax_op.cc
  type caffe2 (line 6) | namespace caffe2 {
    class GLSoftmaxOp (line 8) | class GLSoftmaxOp final : public Operator<GLContext> {
      method GLSoftmaxOp (line 10) | GLSoftmaxOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/operators/spatial_batch_norm_op.cc
  type caffe2 (line 6) | namespace caffe2 {
    class GLSpatialBNOp (line 8) | class GLSpatialBNOp final : public Operator<GLContext> {
      method GLSpatialBNOp (line 10) | GLSpatialBNOp(const OperatorDef &operator_def, Workspace *ws)

FILE: caffe2/mobile/contrib/arm-compute/test/gl_activation_ops_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, Sigmoid) {
    function TEST (line 25) | TEST(OPENGLOperatorTest, ReLU) {
    function TEST (line 45) | TEST(OPENGLOperatorTest, SigmoidTwice) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_alignment_test.cc
  type caffe2 (line 4) | namespace caffe2 {
    function TEST (line 9) | TEST(OPENGLOperatorTest, ConvMaxPoolConv) {
    function TEST (line 78) | TEST(OPENGLOperatorTest, ConvReluConv) {
    function TEST (line 138) | TEST(OPENGLOperatorTest, ConvAddConv) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_concat_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, Concat) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_context_test.cc
  type caffe2 (line 4) | namespace caffe2 {
    function TEST (line 6) | TEST(OPENGLContextTest, Initialization) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_conv_op_test.cc
  type caffe2 (line 4) | namespace caffe2 {
    function TEST (line 8) | TEST(OPENGLOperatorTest, Conv) {
    function TEST (line 51) | TEST(OPENGLOperatorTest, ConvReluConv) {
    function TEST (line 112) | TEST(OPENGLOperatorTest, ConvBenchmark) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_copy_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, CopyFromGL) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_elementwise_sum_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, Sum) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_fully_connected_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, FC) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_model_test.cc
  type caffe2 (line 3) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_model_test.h
  function namespace (line 19) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_norm_planar_yuv_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 7) | TEST(OPENGLOperatorTest, NormPlanarYUV) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_operator_test.h
  function namespace (line 8) | namespace caffe2 {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_pool_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, AveragePool) {
    function TEST (line 33) | TEST(OPENGLOperatorTest, MaxPool) {
    function TEST (line 61) | TEST(OPENGLOperatorTest, AverageGlobalPool) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_resize_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, ResizeNearest) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_softmax_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, Softmax) {

FILE: caffe2/mobile/contrib/arm-compute/test/gl_spatial_batch_norm_op_test.cc
  type caffe2 (line 3) | namespace caffe2 {
    function TEST (line 5) | TEST(OPENGLOperatorTest, SpatialBN) {

FILE: caffe2/mobile/contrib/ios/ios_caffe.cc
  function Caffe2IOSPredictor (line 23) | Caffe2IOSPredictor* MakeCaffe2Predictor(const std::string& init_net_str,
  function GenerateStylizedImage (line 48) | void GenerateStylizedImage(std::vector<float>& originalImage,

FILE: caffe2/mobile/contrib/ios/ios_caffe_predictor.cc
  function Caffe2IOSPredictor (line 27) | Caffe2IOSPredictor* Caffe2IOSPredictor::NewCaffe2IOSPredictor(const caff...

FILE: caffe2/mobile/contrib/ios/ios_caffe_predictor.h
  type Tensor (line 25) | struct Tensor {
  function Caffe2IOSPredictor (line 30) | Caffe2IOSPredictor final {

FILE: caffe2/mobile/contrib/ios/mpscnn/mpscnn.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/mobile/contrib/ios/mpscnn/mpscnn_context.h
  function namespace (line 30) | namespace caffe2 {

FILE: caffe2/mobile/contrib/ios/mpscnn/mpscnn_graph_mask.h
  function namespace (line 22) | namespace caffe2 {

FILE: caffe2/mobile/contrib/ios/mpscnn/mpscnn_kernels.h
  function ushort (line 37) | inline constexpr ushort divRoundUp(ushort x, ushort y) { return (x + (y ...
  function kernel (line 39) | kernel void affine(constant half4* scale[[buffer(0)]],
  function kernel (line 56) | kernel void affine_nonarray(constant half4* scale[[buffer(0)]],
  function kernel (line 71) | kernel void prelu_nonshared(constant half4* weights[[buffer(0)]],
  function kernel (line 89) | kernel void prelu_nonshared_nonarray(constant half4* weights[[buffer(0)]],
  function kernel (line 112) | kernel void instance_norm(
  function kernel (line 222) | kernel void instance_norm_nonarray(
  function kernel (line 325) | kernel void copy_nchw_to_metal(constant float* in[[buffer(0)]],
  function kernel (line 357) | kernel void copy_nchw_to_metal_nonarray(constant float* in[[buffer(0)]],
  function ushort3 (line 390) | ushort3 gid[[thread_position_in_grid]]) {
  function ushort2 (line 417) | ushort2 gid[[thread_position_in_grid]]) {
  function kernel (line 566) | kernel void preprocess_stylizer(device uchar4* in[[buffer(0)]],
  function half4 (line 599) | half4 min_h(0.0h, 0.0h, 0.0h, 255.0h);
  function ushort (line 773) | inline ushort idx_3(ushort z, ushort C0, ushort C1, ushort C2, ushort C3) {
  function ushort (line 786) | inline ushort idx_2(ushort z, ushort C0, ushort C1, ushort C2) {
  function ushort (line 796) | inline ushort idx_1(ushort z, ushort C0, ushort C1) {
  function ushort (line 804) | inline ushort idx_0(ushort z, ushort C0) { return 0; }
  function ushort (line 807) | inline constexpr ushort z_off(ushort n, ushort c, ushort C) { return n *...
  function kernel (line 1085) | kernel void nms(device uint* mask[[buffer(0)]],

FILE: caffe2/mobile/contrib/ios/mpscnn/mpscnn_test.h
  function namespace (line 21) | namespace caffe2 {

FILE: caffe2/mobile/contrib/ios/pool_test.cc
  type caffe2 (line 27) | namespace caffe2 {
    function AddNoiseInput (line 31) | void AddNoiseInput(const vector<TIndex>& shape, const string& name, Wo...
    function compareMaxPooling (line 46) | void compareMaxPooling(int N,
    function randInt (line 117) | int randInt(int a, int b) {
    function runMaxPool (line 123) | void runMaxPool(int kernel, int stride, int pad) {
    function TEST (line 133) | TEST(PoolOp, MaxPool2x2s2p0Randomized) {
    function TEST (line 139) | TEST(PoolOp, MaxPool4x4s3p2Randomized) {
    function TEST (line 145) | TEST(PoolOp, MaxPool2x2s2p0Special) {
    function TEST (line 156) | TEST(PoolOp, MaxPoolFullyRandomized) {

FILE: caffe2/mobile/contrib/ios/resize_test.cc
  type caffe2 (line 27) | namespace caffe2 {
    function AddNoiseInput (line 31) | void AddNoiseInput(const vector<TIndex>& shape, const string& name, Wo...
    function compareResizeNeareast (line 46) | void compareResizeNeareast(int N,
    function randInt (line 95) | int randInt(int a, int b) {
    function TEST (line 101) | TEST(ResizeNearestOp, ResizeNearest2x) {

FILE: caffe2/mobile/contrib/libopencl-stub/include/CL/cl.h
  type _cl_platform_id (line 39) | struct _cl_platform_id
  type _cl_device_id (line 40) | struct _cl_device_id
  type _cl_context (line 41) | struct _cl_context
  type _cl_command_queue (line 42) | struct _cl_command_queue
  type _cl_mem (line 43) | struct _cl_mem
  type _cl_program (line 44) | struct _cl_program
  type _cl_kernel (line 45) | struct _cl_kernel
  type _cl_event (line 46) | struct _cl_event
  type _cl_sampler (line 47) | struct _cl_sampler
  type cl_uint (line 49) | typedef cl_uint             cl_bool;
  type cl_ulong (line 50) | typedef cl_ulong            cl_bitfield;
  type cl_bitfield (line 51) | typedef cl_bitfield         cl_device_type;
  type cl_uint (line 52) | typedef cl_uint             cl_platform_info;
  type cl_uint (line 53) | typedef cl_uint             cl_device_info;
  type cl_bitfield (line 54) | typedef cl_bitfield         cl_device_fp_config;
  type cl_uint (line 55) | typedef cl_uint             cl_device_mem_cache_type;
  type cl_uint (line 56) | typedef cl_uint             cl_device_local_mem_type;
  type cl_bitfield (line 57) | typedef cl_bitfield         cl_device_exec_capabilities;
  type cl_bitfield (line 58) | typedef cl_bitfield         cl_command_queue_properties;
  type cl_device_partition_property (line 59) | typedef intptr_t            cl_device_partition_property;
  type cl_bitfield (line 60) | typedef cl_bitfield         cl_device_affinity_domain;
  type cl_context_properties (line 62) | typedef intptr_t            cl_context_properties;
  type cl_uint (line 63) | typedef cl_uint             cl_context_info;
  type cl_uint (line 64) | typedef cl_uint             cl_command_queue_info;
  type cl_uint (line 65) | typedef cl_uint             cl_channel_order;
  type cl_uint (line 66) | typedef cl_uint             cl_channel_type;
  type cl_bitfield (line 67) | typedef cl_bitfield         cl_mem_flags;
  type cl_uint (line 68) | typedef cl_uint             cl_mem_object_type;
  type cl_uint (line 69) | typedef cl_uint             cl_mem_info;
  type cl_bitfield (line 70) | typedef cl_bitfield         cl_mem_migration_flags;
  type cl_uint (line 71) | typedef cl_uint             cl_image_info;
  type cl_uint (line 72) | typedef cl_uint             cl_buffer_create_type;
  type cl_uint (line 73) | typedef cl_uint             cl_addressing_mode;
  type cl_uint (line 74) | typedef cl_uint             cl_filter_mode;
  type cl_uint (line 75) | typedef cl_uint             cl_sampler_info;
  type cl_bitfield (line 76) | typedef cl_bitfield         cl_map_flags;
  type cl_uint (line 77) | typedef cl_uint             cl_program_info;
  type cl_uint (line 78) | typedef cl_uint             cl_program_build_info;
  type cl_uint (line 79) | typedef cl_uint             cl_program_binary_type;
  type cl_int (line 80) | typedef cl_int              cl_build_status;
  type cl_uint (line 81) | typedef cl_uint             cl_kernel_info;
  type cl_uint (line 82) | typedef cl_uint             cl_kernel_arg_info;
  type cl_uint (line 83) | typedef cl_uint             cl_kernel_arg_address_qualifier;
  type cl_uint (line 84) | typedef cl_uint             cl_kernel_arg_access_qualifier;
  type cl_bitfield (line 85) | typedef cl_bitfield         cl_kernel_arg_type_qualifier;
  type cl_uint (line 86) | typedef cl_uint             cl_kernel_work_group_info;
  type cl_uint (line 87) | typedef cl_uint             cl_event_info;
  type cl_uint (line 88) | typedef cl_uint             cl_command_type;
  type cl_uint (line 89) | typedef cl_uint             cl_profiling_info;
  type cl_image_format (line 92) | typedef struct _cl_image_format {
  type cl_image_desc (line 97) | typedef struct _cl_image_desc {
  type cl_buffer_region (line 110) | typedef struct _cl_buffer_region {

FILE: caffe2/mobile/contrib/libopencl-stub/include/CL/cl.hpp
  type cl (line 230) | namespace cl {
    class Memory (line 232) | class Memory
      method Memory (line 2929) | Memory() : detail::Wrapper<cl_type>() { }
      method Memory (line 2935) | Memory(const Memory& memory) : detail::Wrapper<cl_type>(memory) { }
      method Memory (line 2949) | Memory& operator = (const Memory& rhs)
      method Memory (line 2962) | Memory& operator = (const cl_mem& rhs)
      method cl_int (line 2970) | cl_int getInfo(cl_mem_info name, T* param) const
      method getInfo (line 2978) | typename
      method cl_int (line 3005) | cl_int setDestructorCallback(
    class Program (line 257) | class Program
      method Program (line 4639) | Program(
      method Program (line 4674) | Program(
      method Program (line 4708) | Program(
      method Program (line 4752) | Program(
      method Program (line 4809) | Program(
      method Program (line 4838) | Program() { }
      method Program (line 4840) | Program(const Program& program) : detail::Wrapper<cl_type>(program) { }
      method Program (line 4844) | Program& operator = (const Program& rhs)
      method Program (line 4852) | Program& operator = (const cl_program& rhs)
      method cl_int (line 4858) | cl_int build(
      method cl_int (line 4882) | cl_int build(
      method cl_int (line 4899) | cl_int compile(
      method cl_int (line 4920) | cl_int getInfo(cl_program_info name, T* param) const
      method getInfo (line 4927) | typename
      method cl_int (line 4941) | cl_int getBuildInfo(
      method getBuildInfo (line 4950) | typename
      method cl_int (line 4963) | cl_int createKernels(VECTOR_CLASS<Kernel>* kernels)
    class Device (line 258) | class Device
      method Device (line 1912) | Device() : detail::Wrapper<cl_type>() { }
      method Device (line 1918) | Device(const Device& device) : detail::Wrapper<cl_type>(device) { }
      method Device (line 1924) | Device(const cl_device_id &device) : detail::Wrapper<cl_type>(device...
      method Device (line 1936) | Device& operator = (const Device& rhs)
      method Device (line 1948) | Device& operator = (const cl_device_id& rhs)
      method cl_int (line 1956) | cl_int getInfo(cl_device_info name, T* param) const
      method getInfo (line 1964) | typename
      method cl_int (line 1982) | cl_int createSubDevices(
      method cl_int (line 2008) | cl_int createSubDevices(
    class Context (line 259) | class Context
      method Context (line 2365) | Context(
      method Context (line 2395) | Context(
      method Context (line 2425) | Context(
      method Context (line 2510) | static Context getDefault(cl_int * err = NULL)
      method Context (line 2559) | Context() : detail::Wrapper<cl_type>() { }
      method Context (line 2565) | Context(const Context& context) : detail::Wrapper<cl_type>(context) { }
      method Context (line 2579) | Context& operator = (const Context& rhs)
      method Context (line 2592) | Context& operator = (const cl_context& rhs)
      method cl_int (line 2600) | cl_int getInfo(cl_context_info name, T* param) const
      method getInfo (line 2608) | typename
      method cl_int (line 2625) | cl_int getSupportedImageFormats(
    class CommandQueue (line 260) | class CommandQueue
      method CommandQueue (line 5097) | CommandQueue(
      method CommandQueue (line 5126) | explicit CommandQueue(
      method CommandQueue (line 5155) | CommandQueue(
      method CommandQueue (line 5171) | static CommandQueue getDefault(cl_int * err = NULL)
      method CommandQueue (line 5232) | CommandQueue() { }
      method CommandQueue (line 5234) | CommandQueue(const CommandQueue& commandQueue) : detail::Wrapper<cl_...
      method CommandQueue (line 5236) | CommandQueue(const cl_command_queue& commandQueue) : detail::Wrapper...
      method CommandQueue (line 5238) | CommandQueue& operator = (const CommandQueue& rhs)
      method CommandQueue (line 5246) | CommandQueue& operator = (const cl_command_queue& rhs)
      method cl_int (line 5253) | cl_int getInfo(cl_command_queue_info name, T* param) const
      method getInfo (line 5261) | typename
      method cl_int (line 5274) | cl_int enqueueReadBuffer(
      method cl_int (line 5299) | cl_int enqueueWriteBuffer(
      method cl_int (line 5324) | cl_int enqueueCopyBuffer(
      method cl_int (line 5348) | cl_int enqueueReadBufferRect(
      method cl_int (line 5387) | cl_int enqueueWriteBufferRect(
      method cl_int (line 5426) | cl_int enqueueCopyBufferRect(
      method cl_int (line 5471) | cl_int enqueueFillBuffer(
      method cl_int (line 5500) | cl_int enqueueReadImage(
      method cl_int (line 5527) | cl_int enqueueWriteImage(
      method cl_int (line 5554) | cl_int enqueueCopyImage(
      method cl_int (line 5587) | cl_int enqueueFillImage(
      method cl_int (line 5621) | cl_int enqueueFillImage(
      method cl_int (line 5655) | cl_int enqueueFillImage(
      method cl_int (line 5683) | cl_int enqueueCopyImageToBuffer(
      method cl_int (line 5708) | cl_int enqueueCopyBufferToImage(
      method cl_int (line 5787) | cl_int enqueueUnmapMemObject(
      method cl_int (line 5820) | cl_int enqueueMarkerWithWaitList(
      method cl_int (line 5850) | cl_int enqueueBarrierWithWaitList(
      method cl_int (line 5873) | cl_int enqueueMigrateMemObjects(
      method cl_int (line 5906) | cl_int enqueueNDRangeKernel(
      method cl_int (line 5932) | cl_int enqueueTask(
      method cl_int (line 5952) | cl_int enqueueNativeKernel(
      method CL_EXT_PREFIX__VERSION_1_1_DEPRECATED (line 5992) | CL_EXT_PREFIX__VERSION_1_1_DEPRECATED
      method CL_EXT_PREFIX__VERSION_1

[
  {
    "path": ".gitattributes",
    "chars": 31,
    "preview": "*.ipynb linguist-documentation\n"
  },
  {
    "path": ".github/CONTRIBUTING.md",
    "chars": 0,
    "preview": ""
  },
  {
    "path": ".github/ISSUE_TEMPLATE.md",
    "chars": 302,
    "preview": "If this is a build issue, please fill out the template below.\n\n### System information\n\n* Operating system:\n* Compiler ve"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 0,
    "preview": ""
  },
  {
    "path": ".gitignore",
    "chars": 1139,
    "preview": "## General\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.cuo\n*.obj\n\n# Compiled Dynamic libraries\n*.so\n*.dylib\n*.dll\n\n# Compi"
  },
  {
    "path": ".gitmodules",
    "chars": 2576,
    "preview": "[submodule \"third_party/pybind11\"]\n\tpath = third_party/pybind11\n\turl = https://github.com/pybind/pybind11.git\n[submodule"
  },
  {
    "path": ".jenkins/README.md",
    "chars": 690,
    "preview": "# Jenkins\n\nThe scripts in this directory are the entrypoint for testing Caffe2.\n\nThe environment variable `BUILD_ENVIRON"
  },
  {
    "path": ".jenkins/build.sh",
    "chars": 5590,
    "preview": "#!/bin/bash\n\nset -ex\n\nLOCAL_DIR=$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\nROOT_DIR=$(cd \"$LOCAL_DIR\"/.. && pwd)\n\n# S"
  },
  {
    "path": ".jenkins/test.sh",
    "chars": 3469,
    "preview": "#!/bin/bash\n\nset -ex\n\n# Figure out which Python to use\nPYTHON=\"python\"\nif [ -n \"$BUILD_ENVIRONMENT\" ]; then\n  if [[ \"$BU"
  },
  {
    "path": ".travis/build.sh",
    "chars": 1266,
    "preview": "#!/bin/bash\nset -e\nset -x\n\nLOCAL_DIR=$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\nROOT_DIR=$(dirname \"$LOCAL_DIR\")\n"
  },
  {
    "path": ".travis/install.sh",
    "chars": 7120,
    "preview": "#!/bin/bash\nset -e\nset -x\n\nLOCAL_DIR=$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\nROOT_DIR=$(dirname \"$LOCAL_DIR\")\n"
  },
  {
    "path": ".travis/setup.sh",
    "chars": 1660,
    "preview": "#!/bin/bash\n# This script should be sourced, not executed\nset -e\n\nexport BUILD_ANDROID=false\nexport BUILD_CUDA=false\nexp"
  },
  {
    "path": ".travis/test.sh",
    "chars": 457,
    "preview": "#!/bin/bash\nset -e\nset -x\n\nLOCAL_DIR=$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\nROOT_DIR=$(dirname \"$LOCAL_DIR\")\n"
  },
  {
    "path": ".travis.yml",
    "chars": 783,
    "preview": "os: linux\ndist: trusty\nsudo: required\nlanguage: cpp\ncompiler: gcc\n\nenv:\n  global:\n    - BUILD_CCACHE_DIR=~/build/ccache\n"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 10290,
    "preview": "cmake_minimum_required(VERSION 3.2 FATAL_ERROR)\n#cmake_policy(SET CMP0022 NEW)\n#cmake_policy(SET CMP0023 NEW)\n\n# ---[ Pr"
  },
  {
    "path": "LICENSE",
    "chars": 11357,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "Makefile",
    "chars": 527,
    "preview": "# This makefile does nothing but delegating the actual building to cmake.\n\nall:\n\t@mkdir -p build && cd build && cmake .."
  },
  {
    "path": "NOTICE",
    "chars": 5572,
    "preview": "Copyright (c) 2016-present, Facebook Inc. All rights reserved.\n\nAll contributions by Facebook:\nCopyright (c) 2016 Facebo"
  },
  {
    "path": "README.md",
    "chars": 1718,
    "preview": "# Caffe2\n\n[![License](https://img.shields.io/badge/License-Apache%202.0-brightgreen.svg)](https://opensource.org/license"
  },
  {
    "path": "VERSION_NUMBER",
    "chars": 5,
    "preview": "0.8.1"
  },
  {
    "path": "appveyor.yml",
    "chars": 1499,
    "preview": "version: '{build}'\nclone_folder: c:\\projects\\caffe2\nenvironment:\n  matrix:\n    - USE_CUDA: OFF\n      CMAKE_BUILD_TYPE: R"
  },
  {
    "path": "binaries/CMakeLists.txt",
    "chars": 1522,
    "preview": "caffe2_binary_target(\"convert_caffe_image_db.cc\")\ncaffe2_binary_target(\"convert_db.cc\")\ncaffe2_binary_target(\"make_cifar"
  },
  {
    "path": "binaries/caffe2_benchmark.cc",
    "chars": 8435,
    "preview": "#include <fstream>\n#include <iterator>\n#include <string>\n\n#include \"caffe2/core/blob_serialization.h\"\n#include \"caffe2/c"
  },
  {
    "path": "binaries/convert_caffe_image_db.cc",
    "chars": 3390,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/convert_db.cc",
    "chars": 1918,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/convert_encoded_to_raw_leveldb.cc",
    "chars": 5300,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/core_overhead_benchmark.cc",
    "chars": 6472,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/db_throughput.cc",
    "chars": 3356,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/inspect_gpus.cc",
    "chars": 1642,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/make_cifar_db.cc",
    "chars": 5150,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/make_image_db.cc",
    "chars": 8003,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/make_mnist_db.cc",
    "chars": 4974,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/predictor_verifier.cc",
    "chars": 1985,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/print_core_object_sizes.cc",
    "chars": 1427,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/print_registered_core_operators.cc",
    "chars": 2396,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/run_plan.cc",
    "chars": 1424,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/run_plan_mpi.cc",
    "chars": 1741,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/speed_benchmark.cc",
    "chars": 6092,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/split_db.cc",
    "chars": 2742,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/tutorial_blob.cc",
    "chars": 2554,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "binaries/zmq_feeder.cc",
    "chars": 2228,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "caffe/proto/CMakeLists.txt",
    "chars": 574,
    "preview": "file(GLOB Caffe_PROTOBUF_FILES \"${CMAKE_CURRENT_SOURCE_DIR}/*.proto\")\n\ncaffe2_protobuf_generate_cpp_py(Caffe_PROTO_SRCS "
  },
  {
    "path": "caffe/proto/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "caffe/proto/caffe.proto",
    "chars": 57545,
    "preview": "syntax = \"proto2\";\n\npackage caffe;\n\n// Specifies the shape (dimensions) of a Blob.\nmessage BlobShape {\n  repeated int64 "
  },
  {
    "path": "caffe2/.clang-format",
    "chars": 2540,
    "preview": "---\nAccessModifierOffset: -1\nAlignAfterOpenBracket: AlwaysBreak\nAlignConsecutiveAssignments: false\nAlignConsecutiveDecla"
  },
  {
    "path": "caffe2/CMakeLists.txt",
    "chars": 10642,
    "preview": "# ---[ Declare source file lists\n\n# ---[ Add respective subdirectories\n# Note: the folders that are being commented out "
  },
  {
    "path": "caffe2/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "caffe2/contrib/CMakeLists.txt",
    "chars": 647,
    "preview": "add_subdirectory(aten)\nadd_subdirectory(gloo)\nadd_subdirectory(nccl)\nadd_subdirectory(prof)\nadd_subdirectory(shm_mutex)\n"
  },
  {
    "path": "caffe2/contrib/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "caffe2/contrib/aten/CMakeLists.txt",
    "chars": 1124,
    "preview": "if(USE_ATEN)\n  if(NOT USE_CUDA)\n    set(NO_CUDA ON)\n  endif()\n  set(TORCH_CUDA_ARCH_LIST \"3.5 5.2 6.0 6.1+PTX\")\n  set(TO"
  },
  {
    "path": "caffe2/contrib/aten/README.md",
    "chars": 2537,
    "preview": "# An ATen operator for Caffe2\n\n[ATen](https://github.com/zdevito/aten) is a simple tensor library thats exposes the Tens"
  },
  {
    "path": "caffe2/contrib/aten/aten_op.cc",
    "chars": 1053,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/aten/aten_op.h",
    "chars": 52,
    "preview": "#include \"caffe2/caffe2/contrib/aten/gen_aten_op.h\"\n"
  },
  {
    "path": "caffe2/contrib/aten/aten_op_cuda.cc",
    "chars": 1013,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/aten/aten_op_template.h",
    "chars": 8106,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/aten/aten_test.py",
    "chars": 2838,
    "preview": "# Copyright (c) 2016-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you m"
  },
  {
    "path": "caffe2/contrib/aten/docs/pytorch_to_caffe2.md",
    "chars": 5421,
    "preview": "# Using ONNX and ATen to export models from PyTorch to Caffe2\n\nWhen using ONNX to export a model from PyTorch into Caffe"
  },
  {
    "path": "caffe2/contrib/aten/docs/sample.py",
    "chars": 1622,
    "preview": "import numpy as np\n\nfrom torch import nn\nfrom torch.autograd import Variable, Function\nimport torch.onnx\n\nimport onnx\nim"
  },
  {
    "path": "caffe2/contrib/aten/gen_op.py",
    "chars": 10069,
    "preview": "#!/bin/env python\n\n# Copyright (c) 2016-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the "
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/LICENSE",
    "chars": 11358,
    "preview": "\n                                 Apache License\n                           Version 2.0, January 2004\n                  "
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/README.md",
    "chars": 233,
    "preview": "# cuda-convnet2\nAutomatically exported from code.google.com/p/cuda-convnet2\n\nYou can read the documentation in two ways:"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/build.sh",
    "chars": 1916,
    "preview": "#!/bin/sh\n# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"Li"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/convdata.py",
    "chars": 14675,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/convnet.py",
    "chars": 14400,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconv3/Makefile",
    "chars": 3590,
    "preview": "################################################################################\n#\n# Copyright 1993-2012 NVIDIA Corporat"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconv3/include/conv_util.cuh",
    "chars": 34710,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconv3/include/cudaconv2.cuh",
    "chars": 4925,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/conv_util.cu",
    "chars": 160232,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/filter_acts.cu",
    "chars": 165557,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/img_acts.cu",
    "chars": 218326,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/weight_acts.cu",
    "chars": 174590,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/Makefile",
    "chars": 3939,
    "preview": "################################################################################\n#\n# Copyright 1993-2012 NVIDIA Corporat"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/actbroadcaster.cuh",
    "chars": 1805,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/convnet.cuh",
    "chars": 5363,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/copypipeline.cuh",
    "chars": 6838,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/cost.cuh",
    "chars": 1456,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/data.cuh",
    "chars": 2690,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/gradreducer.cuh",
    "chars": 2461,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/jpeg.h",
    "chars": 1829,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/layer.cuh",
    "chars": 28469,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/layer_kernels.cuh",
    "chars": 3487,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/lr.cuh",
    "chars": 2043,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/memorysource.cuh",
    "chars": 1951,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/messages.cuh",
    "chars": 3130,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/neuron.cuh",
    "chars": 14966,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/pipedispenser.cuh",
    "chars": 4148,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/pyconvnet.cuh",
    "chars": 1270,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/reducepipeline.cuh",
    "chars": 5706,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/streambroadcast.cuh",
    "chars": 1917,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/timer.cuh",
    "chars": 1247,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/util.cuh",
    "chars": 4307,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/weights.cuh",
    "chars": 4981,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/worker.cuh",
    "chars": 3009,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/actbroadcaster.cu",
    "chars": 3070,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/convnet.cu",
    "chars": 27069,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/copypipeline.cu",
    "chars": 12840,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/cost.cu",
    "chars": 3298,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/data.cu",
    "chars": 2598,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/gradreducer.cu",
    "chars": 6749,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/jpeg.cpp",
    "chars": 5274,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/layer.cu",
    "chars": 90354,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/layer_kernels.cu",
    "chars": 21818,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/lr.cu",
    "chars": 3592,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/memorysource.cu",
    "chars": 4008,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/neuron.cu",
    "chars": 2084,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/pyconvnet.cu",
    "chars": 9190,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/reducepipeline.cu",
    "chars": 13162,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/streambroadcast.cu",
    "chars": 7319,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/util.cu",
    "chars": 6262,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/weights.cu",
    "chars": 13994,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/worker.cu",
    "chars": 10571,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/initw.py",
    "chars": 2020,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layer.py",
    "chars": 82481,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-cifar10-11pct.cfg",
    "chars": 1266,
    "preview": "# 11% error on CIFAR-10 - layer parameter file\n# Methodology:\n# 1. Train on batches 1-4, use batch 5 for validation.\n# 2"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-1gpu.cfg",
    "chars": 1376,
    "preview": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFact"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-2gpu-data.cfg",
    "chars": 1376,
    "preview": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFact"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-2gpu-model.cfg",
    "chars": 2572,
    "preview": "[conv1a]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-4gpu-data-model.cfg",
    "chars": 2448,
    "preview": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFact"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-4gpu-data.cfg",
    "chars": 1376,
    "preview": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFact"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layers-cifar10-11pct.cfg",
    "chars": 990,
    "preview": "[data]\ntype=data\ndataIdx=0\n\n[labels]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=2\n"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-1gpu.cfg",
    "chars": 1496,
    "preview": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\n"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-2gpu-data.cfg",
    "chars": 1482,
    "preview": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\n"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-2gpu-model.cfg",
    "chars": 3112,
    "preview": "[data]\ntype=data\ndataIdx=0\n\n[labels]\ntype=data\ndataIdx=1\n\n[conv1a]\ntype=conv\ninputs=data\nchannels=3\nfilters=48\npadding=0"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-4gpu-data-model.cfg",
    "chars": 2730,
    "preview": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\n"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-4gpu-data.cfg",
    "chars": 1490,
    "preview": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\n"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/make-data/make-data.py",
    "chars": 7155,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/Makefile",
    "chars": 1433,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/__init__.py",
    "chars": 597,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/include/pyext.h",
    "chars": 1555,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/src/pyext.cpp",
    "chars": 4578,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/Makefile",
    "chars": 3564,
    "preview": "################################################################################\n#\n# Copyright 1993-2012 NVIDIA Corporat"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/memory.cuh",
    "chars": 11199,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/nvmatrix.cuh",
    "chars": 32013,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/nvmatrix_kernels.cuh",
    "chars": 27599,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/nvmatrix_operators.cuh",
    "chars": 12141,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/src/memory.cu",
    "chars": 2842,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/src/nvmatrix.cu",
    "chars": 60287,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/nvmatrix/src/nvmatrix_kernels.cu",
    "chars": 2663,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/python_util/__init__.py",
    "chars": 597,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/python_util/data.py",
    "chars": 7803,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/python_util/gpumodel.py",
    "chars": 14896,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/python_util/options.py",
    "chars": 16577,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/python_util/util.py",
    "chars": 2825,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/shownet.py",
    "chars": 18206,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/util/Makefile",
    "chars": 1539,
    "preview": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/util/include/matrix.h",
    "chars": 9729,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/util/include/matrix_funcs.h",
    "chars": 2393,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/util/include/queue.h",
    "chars": 3044,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/util/include/sync.h",
    "chars": 2054,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/util/include/thread.h",
    "chars": 3121,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/cuda-convnet2/util/src/matrix.cpp",
    "chars": 25540,
    "preview": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "caffe2/contrib/docker-ubuntu-14.04/Dockerfile",
    "chars": 3788,
    "preview": "FROM ubuntu:14.04\nMAINTAINER caffe-dev <caffe-dev@googlegroups.com>\n\n# A docker container with CUDA and caffe2 installed"
  },
  {
    "path": "caffe2/contrib/gloo/CMakeLists.txt",
    "chars": 895,
    "preview": "if(USE_GLOO)\n  set(Caffe2_CONTRIB_GLOO_CPU_SRC\n    \"${CMAKE_CURRENT_SOURCE_DIR}/allgather_ops.cc\"\n    \"${CMAKE_CURRENT_S"
  },
  {
    "path": "caffe2/contrib/gloo/allgather_ops.cc",
    "chars": 1964,
    "preview": "/**\n * Copyright (c) 2017-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/allgather_ops.h",
    "chars": 3810,
    "preview": "/**\n * Copyright (c) 2017-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/allreduce_ops.cc",
    "chars": 2663,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/allreduce_ops.h",
    "chars": 4234,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/allreduce_ops_gpu.cc",
    "chars": 3803,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/barrier_ops.cc",
    "chars": 819,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/barrier_ops.h",
    "chars": 2319,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/broadcast_ops.cc",
    "chars": 1799,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/broadcast_ops.h",
    "chars": 3778,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/broadcast_ops_gpu.cc",
    "chars": 1860,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/common.cc",
    "chars": 1978,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/common.h",
    "chars": 2278,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/common_world_ops.cc",
    "chars": 1220,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/common_world_ops.h",
    "chars": 7823,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/common_world_ops_gpu.cc",
    "chars": 1402,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/context.cc",
    "chars": 823,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/context.h",
    "chars": 653,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/gloo_test.py",
    "chars": 24766,
    "preview": "# Copyright (c) 2016-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you m"
  },
  {
    "path": "caffe2/contrib/gloo/py_export.cc",
    "chars": 294,
    "preview": "#include <gloo/common/error.h>\n#include <pybind11/pybind11.h>\n\nnamespace gloo {\nnamespace python {\n\nnamespace py = pybin"
  },
  {
    "path": "caffe2/contrib/gloo/reduce_scatter_ops.cc",
    "chars": 1558,
    "preview": "/**\n * Copyright (c) 2018-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/reduce_scatter_ops.h",
    "chars": 3984,
    "preview": "/**\n * Copyright (c) 2018-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/store_handler.cc",
    "chars": 1226,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/gloo/store_handler.h",
    "chars": 1434,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nccl/CMakeLists.txt",
    "chars": 427,
    "preview": "if(USE_NCCL)\n    message(STATUS \"Include NCCL operators\")\n    set(Caffe2_CONTRIB_NCCL_GPU_SRC\n        \"${CMAKE_CURRENT_S"
  },
  {
    "path": "caffe2/contrib/nccl/cuda_nccl_gpu.cc",
    "chars": 9519,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nccl/cuda_nccl_gpu.h",
    "chars": 2081,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nccl/cuda_nccl_op_gpu.cc",
    "chars": 6712,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nccl/nccl_ops_test.py",
    "chars": 8950,
    "preview": "# Copyright (c) 2016-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you m"
  },
  {
    "path": "caffe2/contrib/nervana/CMakeLists.txt",
    "chars": 455,
    "preview": "if(USE_NERVANA_GPU)\n  message(STATUS \"Include Nervana operators\")\n  set(Caffe2_CONTRIB_NCCL_GPU_SRC\n    \"${CMAKE_CURRENT"
  },
  {
    "path": "caffe2/contrib/nervana/nervana.h",
    "chars": 1320,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nervana/nervana_c_api.cu",
    "chars": 12620,
    "preview": "/*\n * Copyright 2015 Baidu USA, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "caffe2/contrib/nervana/nervana_c_api.h",
    "chars": 5804,
    "preview": "/*\n * Copyright 2015 Baidu USA, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "caffe2/contrib/nervana/nervana_fc_op_gpu.cc",
    "chars": 996,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nervana/nervana_fc_op_gpu_test.cc",
    "chars": 2594,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nervana/nervana_init_gpu.cc",
    "chars": 2385,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nervana/nervana_math_gpu.cc",
    "chars": 1815,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nnpack/nnpack_ops.cc",
    "chars": 13263,
    "preview": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
  },
  {
    "path": "caffe2/contrib/nnpack/nnpack_ops_test.py",
    "chars": 8963,
    "preview": "# Copyright (c) 2016-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you m"
  },
  {
    "path": "caffe2/contrib/playground/AnyExp.py",
    "chars": 19514,
    "preview": "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __futu"
  },
  {
    "path": "caffe2/contrib/playground/AnyExpOnTerm.py",
    "chars": 1046,
    "preview": "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __futu"
  },
  {
    "path": "caffe2/contrib/playground/ModuleRegister.py",
    "chars": 4206,
    "preview": "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __futu"
  },
  {
    "path": "caffe2/contrib/playground/README.md",
    "chars": 10704,
    "preview": "# Playground for Caffe2 Models\n\nPlayground is created to allow modelers to reuse the components of their models.  It is "
  },
  {
    "path": "caffe2/contrib/playground/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "caffe2/contrib/playground/checkpoint.py",
    "chars": 6984,
    "preview": "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __futu"
  },
  {
    "path": "caffe2/contrib/playground/compute_loss.py",
    "chars": 1110,
    "preview": "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __futu"
  }
]

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