caffe2安装文件

【实例简介】
caffe2安装文件。。。。。。。。。。。。。。。。。。。。。。
【实例截图】
【核心代码】
80986620-7c29-49f6-8719-89b0bd94ce8b
└── caffe2-master
├── appveyor.yml
├── binaries
│   ├── caffe2_benchmark.cc
│   ├── CMakeLists.txt
│   ├── 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
│   ├── caffe.proto
│   ├── CMakeLists.txt
│   └── __init__.py
├── caffe2
│   ├── CMakeLists.txt
│   ├── contrib
│   │   ├── aten
│   │   │   ├── aten_op.cc
│   │   │   ├── aten_op_cuda.cc
│   │   │   ├── aten_op.h
│   │   │   ├── aten_op_template.h
│   │   │   ├── aten_test.py
│   │   │   ├── CMakeLists.txt
│   │   │   ├── docs
│   │   │   │   ├── pytorch_to_caffe2.md
│   │   │   │   └── sample.py
│   │   │   ├── gen_op.py
│   │   │   └── README.md
│   │   ├── CMakeLists.txt
│   │   ├── cuda-convnet2
│   │   │   ├── build.sh
│   │   │   ├── convdata.py
│   │   │   ├── convnet.py
│   │   │   ├── cudaconv3
│   │   │   │   ├── include
│   │   │   │   │   ├── conv_util.cuh
│   │   │   │   │   └── cudaconv2.cuh
│   │   │   │   ├── Makefile
│   │   │   │   └── src
│   │   │   │   ├── conv_util.cu
│   │   │   │   ├── filter_acts.cu
│   │   │   │   ├── img_acts.cu
│   │   │   │   └── weight_acts.cu
│   │   │   ├── cudaconvnet
│   │   │   │   ├── 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
│   │   │   │   ├── __init__.py
│   │   │   │   ├── Makefile
│   │   │   │   └── 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
│   │   │   ├── images
│   │   │   │   ├── show-cost.png
│   │   │   │   ├── show-filters-no-rgb.png
│   │   │   │   ├── show-filters.png
│   │   │   │   └── show-preds.png
│   │   │   ├── 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.cfg
│   │   │   │   ├── layer-params-imagenet-4gpu-data-model.cfg
│   │   │   │   ├── layers-cifar10-11pct.cfg
│   │   │   │   ├── layers-imagenet-1gpu.cfg
│   │   │   │   ├── layers-imagenet-2gpu-data.cfg
│   │   │   │   ├── layers-imagenet-2gpu-model.cfg
│   │   │   │   ├── layers-imagenet-4gpu-data.cfg
│   │   │   │   └── layers-imagenet-4gpu-data-model.cfg
│   │   │   ├── LICENSE
│   │   │   ├── make-data
│   │   │   │   ├── input_meta
│   │   │   │   ├── make-data.py
│   │   │   │   └── pyext
│   │   │   │   ├── include
│   │   │   │   │   └── pyext.h
│   │   │   │   ├── __init__.py
│   │   │   │   ├── Makefile
│   │   │   │   └── src
│   │   │   │   └── pyext.cpp
│   │   │   ├── nvmatrix
│   │   │   │   ├── include
│   │   │   │   │   ├── memory.cuh
│   │   │   │   │   ├── nvmatrix.cuh
│   │   │   │   │   ├── nvmatrix_kernels.cuh
│   │   │   │   │   └── nvmatrix_operators.cuh
│   │   │   │   ├── Makefile
│   │   │   │   └── src
│   │   │   │   ├── memory.cu
│   │   │   │   ├── nvmatrix.cu
│   │   │   │   └── nvmatrix_kernels.cu
│   │   │   ├── python_util
│   │   │   │   ├── data.py
│   │   │   │   ├── gpumodel.py
│   │   │   │   ├── __init__.py
│   │   │   │   ├── options.py
│   │   │   │   └── util.py
│   │   │   ├── README.md
│   │   │   ├── shownet.py
│   │   │   └── util
│   │   │   ├── include
│   │   │   │   ├── matrix_funcs.h
│   │   │   │   ├── matrix.h
│   │   │   │   ├── queue.h
│   │   │   │   ├── sync.h
│   │   │   │   └── thread.h
│   │   │   ├── Makefile
│   │   │   └── src
│   │   │   └── matrix.cpp
│   │   ├── docker-ubuntu-14.04
│   │   │   └── Dockerfile
│   │   ├── gloo
│   │   │   ├── allgather_ops.cc
│   │   │   ├── allgather_ops.h
│   │   │   ├── allreduce_ops.cc
│   │   │   ├── allreduce_ops_gpu.cc
│   │   │   ├── allreduce_ops.h
│   │   │   ├── barrier_ops.cc
│   │   │   ├── barrier_ops.h
│   │   │   ├── broadcast_ops.cc
│   │   │   ├── broadcast_ops_gpu.cc
│   │   │   ├── broadcast_ops.h
│   │   │   ├── CMakeLists.txt
│   │   │   ├── common.cc
│   │   │   ├── common.h
│   │   │   ├── common_world_ops.cc
│   │   │   ├── common_world_ops_gpu.cc
│   │   │   ├── common_world_ops.h
│   │   │   ├── context.cc
│   │   │   ├── context.h
│   │   │   ├── gloo_test.py
│   │   │   ├── py_export.cc
│   │   │   ├── reduce_scatter_ops.cc
│   │   │   ├── reduce_scatter_ops.h
│   │   │   ├── store_handler.cc
│   │   │   └── store_handler.h
│   │   ├── __init__.py
│   │   ├── nccl
│   │   │   ├── CMakeLists.txt
│   │   │   ├── cuda_nccl_gpu.cc
│   │   │   ├── cuda_nccl_gpu.h
│   │   │   ├── cuda_nccl_op_gpu.cc
│   │   │   └── nccl_ops_test.py
│   │   ├── nervana
│   │   │   ├── CMakeLists.txt
│   │   │   ├── nervana_c_api.cu
│   │   │   ├── nervana_c_api.h
│   │   │   ├── nervana_fc_op_gpu.cc
│   │   │   ├── nervana_fc_op_gpu_test.cc
│   │   │   ├── nervana.h
│   │   │   ├── nervana_init_gpu.cc
│   │   │   └── nervana_math_gpu.cc
│   │   ├── nnpack
│   │   │   ├── nnpack_ops.cc
│   │   │   └── nnpack_ops_test.py
│   │   ├── playground
│   │   │   ├── AnyExpOnTerm.py
│   │   │   ├── AnyExp.py
│   │   │   ├── checkpoint.py
│   │   │   ├── compute_loss.py
│   │   │   ├── compute_topk_accuracy.py
│   │   │   ├── __init__.py
│   │   │   ├── meter.py
│   │   │   ├── module_map.py
│   │   │   ├── ModuleRegister.py
│   │   │   ├── output_generator.py
│   │   │   ├── README.md
│   │   │   └── resnet50demo
│   │   │   ├── caffe2_resnet50_default_forward.py
│   │   │   ├── caffe2_resnet50_default_param_update.py
│   │   │   ├── explicit_resnet_forward.py
│   │   │   ├── explicit_resnet_param_update.py
│   │   │   ├── gfs_IN1k.py
│   │   │   ├── IN1k_resnet50.py
│   │   │   ├── __init__.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
│   │   │   ├── caffe2_script_test.py
│   │   │   ├── CMakeLists.txt
│   │   │   ├── 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_exporter.py
│   │   │   ├── tensorboard_exporter_test.py
│   │   │   ├── tensorboard.md
│   │   │   ├── tensorboard.py
│   │   │   └── tensorboard_test.py
│   │   ├── torch
│   │   │   ├── th_ops.cc
│   │   │   ├── th_ops_gpu.cu
│   │   │   ├── th_ops_test.py
│   │   │   ├── torch_op.cpp
│   │   │   ├── torch_op_gpu.cpp
│   │   │   ├── torch_op.h
│   │   │   └── torch_ops_test.py
│   │   └── warpctc
│   │   ├── ctc_op.cpp
│   │   ├── ctc_op_gpu.cpp
│   │   ├── ctc_op.h
│   │   └── ctc_ops_test.py
│   ├── core
│   │   ├── allocator.cc
│   │   ├── allocator.h
│   │   ├── asan.h
│   │   ├── blob_gpu_test.cc
│   │   ├── blob.h
│   │   ├── blob_serialization.cc
│   │   ├── blob_serialization_gpu.cc
│   │   ├── blob_serialization.h
│   │   ├── blob_serializer_base.h
│   │   ├── blob_stats.cc
│   │   ├── blob_stats.h
│   │   ├── blob_test.cc
│   │   ├── CMakeLists.txt
│   │   ├── common.cc
│   │   ├── common_cudnn.cc
│   │   ├── common_cudnn.h
│   │   ├── common_gpu.cc
│   │   ├── common_gpu.h
│   │   ├── common.h
│   │   ├── common_omp.h
│   │   ├── common_test.cc
│   │   ├── context.cc
│   │   ├── context_gpu.cu
│   │   ├── context_gpu.h
│   │   ├── context_gpu_test.cc
│   │   ├── context.h
│   │   ├── context_test.cc
│   │   ├── cudnn_wrappers.h
│   │   ├── db.cc
│   │   ├── db.h
│   │   ├── event.cc
│   │   ├── event_cpu.h
│   │   ├── event_gpu.cc
│   │   ├── event_gpu_test.cc
│   │   ├── event.h
│   │   ├── 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_async_base.cc
│   │   ├── net_async_base.h
│   │   ├── net_async_dag_gpu.cc
│   │   ├── net_async_dag_gpu.h
│   │   ├── net_async_gpu_thread_pool_gpu.cc
│   │   ├── net_async_gpu_thread_pool.h
│   │   ├── net_async_polling.cc
│   │   ├── net_async_polling.h
│   │   ├── net_async_scheduling.cc
│   │   ├── net_async_scheduling.h
│   │   ├── net.cc
│   │   ├── net_dag.cc
│   │   ├── net_dag.h
│   │   ├── net_dag_utils.cc
│   │   ├── net_dag_utils.h
│   │   ├── net_gpu_test.cc
│   │   ├── net.h
│   │   ├── net_simple_async.cc
│   │   ├── net_simple_async.h
│   │   ├── net_simple.cc
│   │   ├── net_simple.h
│   │   ├── net_singlethread_async_gpu.cc
│   │   ├── net_test.cc
│   │   ├── numa.cc
│   │   ├── numa.h
│   │   ├── observer.h
│   │   ├── observer_test.cc
│   │   ├── operator.cc
│   │   ├── operator_gpu_test.cc
│   │   ├── operator_gradient.h
│   │   ├── operator.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_elfx86.h
│   │   ├── static_tracepoint.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_gpu.cc
│   │   ├── create_db_op.h
│   │   ├── 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_gpu.cc
│   │   ├── file_store_handler_op.h
│   │   ├── 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_gpu.cc
│   │   ├── redis_store_handler_op.h
│   │   ├── 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_gpu.cc
│   │   │   ├── fully_connected_op_decomposition.h
│   │   │   ├── 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_gpu.cc
│   │   │   ├── tt_contraction_op.h
│   │   │   ├── tt_pad_op.cc
│   │   │   └── tt_pad_op.h
│   │   └── python
│   │   ├── 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
│   │   ├── SparseTransformer.py
│   │   ├── tt_contraction_op_test.py
│   │   └── tt_pad_op_test.py
│   ├── image
│   │   ├── CMakeLists.txt
│   │   ├── image_input_op.cc
│   │   ├── image_input_op_gpu.cc
│   │   ├── image_input_op.h
│   │   ├── transform_gpu.cu
│   │   └── transform_gpu.h
│   ├── __init__.py
│   ├── mkl
│   │   ├── CMakeLists.txt
│   │   ├── mklmemory_serialization.cc
│   │   ├── mklmemory_serialization_test.cc
│   │   ├── mkl_operator.cc
│   │   ├── mkl_utils.h
│   │   ├── mkl_utils_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
│   │   ├── arm-compute
│   │   │   ├── CMakeLists.txt
│   │   │   ├── 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
│   │   │   │   ├── activation_ops.cc
│   │   │   │   ├── activation_ops.h
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── 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
│   │   │   ├── README.md
│   │   │   ├── 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
│   │   ├── CMakeLists.txt
│   │   ├── ios
│   │   │   ├── CMakeLists.txt
│   │   │   ├── ios_caffe.cc
│   │   │   ├── ios_caffe_defines.h
│   │   │   ├── ios_caffe.h
│   │   │   ├── ios_caffe_predictor.cc
│   │   │   ├── ios_caffe_predictor.h
│   │   │   ├── mpscnn
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── mpscnn_context.h
│   │   │   │   ├── mpscnn_context.mm
│   │   │   │   ├── mpscnn_graph_mask.h
│   │   │   │   ├── mpscnn_graph_mask.mm
│   │   │   │   ├── mpscnn_graph.mm
│   │   │   │   ├── mpscnn.h
│   │   │   │   ├── mpscnn_kernels.h
│   │   │   │   ├── MPSCNN.metal
│   │   │   │   ├── mpscnn.mm
│   │   │   │   ├── mpscnn_test.h
│   │   │   │   └── mpscnn_test.mm
│   │   │   ├── pool_test.cc
│   │   │   └── resize_test.cc
│   │   ├── libopencl-stub
│   │   │   ├── Android.mk
│   │   │   ├── include
│   │   │   │   ├── CL
│   │   │   │   │   ├── cl_ext.h
│   │   │   │   │   ├── cl_gl_ext.h
│   │   │   │   │   ├── cl_gl.h
│   │   │   │   │   ├── cl.h
│   │   │   │   │   ├── cl.hpp
│   │   │   │   │   ├── cl_platform.h
│   │   │   │   │   └── opencl.h
│   │   │   │   └── libopencl.h
│   │   │   ├── LICENSE
│   │   │   ├── Makefile
│   │   │   ├── README.md
│   │   │   └── src
│   │   │   └── libopencl.c
│   │   ├── libvulkan-stub
│   │   │   ├── include
│   │   │   │   ├── libvulkan-stub.h
│   │   │   │   └── vulkan
│   │   │   │   ├── vk_platform.h
│   │   │   │   └── vulkan.h
│   │   │   └── src
│   │   │   └── libvulkan-stub.c
│   │   ├── nnapi
│   │   │   ├── CMakeLists.txt
│   │   │   ├── dlnnapi.c
│   │   │   ├── dlnnapi.h
│   │   │   ├── NeuralNetworks.h
│   │   │   ├── nnapi_benchmark.cc
│   │   │   ├── nnapi.cc
│   │   │   ├── nnapi.h
│   │   │   └── nnapi_test.cc
│   │   ├── opengl
│   │   │   ├── android
│   │   │   │   ├── AndroidGLContext.cc
│   │   │   │   ├── AndroidGLContext.h
│   │   │   │   ├── arm_neon_support.h
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── gl3stub.c
│   │   │   │   ├── gl3stub.h
│   │   │   │   ├── GLContext.cc
│   │   │   │   └── GLImageAllocator.cc
│   │   │   ├── CMakeLists.txt
│   │   │   ├── core
│   │   │   │   ├── arm_neon_support.h
│   │   │   │   ├── CMakeLists.txt
│   │   │   │   ├── DataTransfer.cc
│   │   │   │   ├── DataTransfer.h
│   │   │   │   ├── GLContext.cc
│   │   │   │   ├── GLContext.h
│   │   │   │   ├── GLFilter.cc
│   │   │   │   ├── GLFilter.h
│   │   │   │   ├── GL.h
│   │   │   │   ├── GLImageAllocator.cc
│   │   │   │   ├── GLImageAllocator.h
│   │   │   │   ├── GLImage.cc
│   │   │   │   ├── GLImage.h
│   │   │   │   ├── GLLogging.h
│   │   │   │   ├── GLPBO.cc
│   │   │   │   ├── GLPBO.h
│   │   │   │   ├── GLPlainTexture.cc
│   │   │   │   ├── GLPlainTexture.h
│   │   │   │   ├── GLPredictor.cc
│   │   │   │   ├── GLPredictor.h
│   │   │   │   ├── GLTexture.cc
│   │   │   │   ├── GLTexture.h
│   │   │   │   ├── ImageAllocator.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
│   │   │   │   ├── GLPadImage.cc
│   │   │   │   ├── GLPool.cc
│   │   │   │   ├── GLPRelu.cc
│   │   │   │   ├── GLResize.cc
│   │   │   │   ├── GLSigmoid.cc
│   │   │   │   ├── GLSoftmax.cc
│   │   │   │   ├── GLStylizer.cc
│   │   │   │   ├── GLSub.cc
│   │   │   │   └── gl_tiling_utils.h
│   │   │   └── test
│   │   │   ├── opengl_test.cc
│   │   │   ├── opengl_test.h
│   │   │   ├── TestGLConvolution.cc
│   │   │   └── TestGLConvolution.h
│   │   ├── snpe
│   │   │   ├── CMakeLists.txt
│   │   │   ├── README.md
│   │   │   ├── snpe_ffi.cc
│   │   │   ├── snpe_ffi.h
│   │   │   ├── snpe_globals.cc
│   │   │   ├── snpe_op_benchmark.cc
│   │   │   └── snpe_op.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_gpu.cc
│   │   ├── mpi_ops.h
│   │   └── mpi_test.cc
│   ├── observers
│   │   ├── CMakeLists.txt
│   │   ├── operator_attaching_net_observer.h
│   │   ├── README.md
│   │   ├── runcnt_observer.cc
│   │   ├── runcnt_observer.h
│   │   ├── time_observer.cc
│   │   ├── time_observer.h
│   │   └── time_observer_test.cc
│   ├── onnx
│   │   ├── backend.cc
│   │   ├── backend.h
│   │   ├── backend_rep.cc
│   │   ├── backend_rep.h
│   │   ├── CMakeLists.txt
│   │   ├── device.cc
│   │   ├── device.h
│   │   ├── helper.cc
│   │   └── helper.h
│   ├── operators
│   │   ├── 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_gpu_test.cc
│   │   ├── batch_matmul_op.h
│   │   ├── 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_gpu.cu
│   │   ├── channel_shuffle_op.h
│   │   ├── channel_stats_op.cc
│   │   ├── channel_stats_op.cu
│   │   ├── channel_stats_op.h
│   │   ├── clip_op.cc
│   │   ├── clip_op.cu
│   │   ├── clip_op.h
│   │   ├── CMakeLists.txt
│   │   ├── communicator_op.cc
│   │   ├── communicator_op_gpu.cc
│   │   ├── concat_split_op.cc
│   │   ├── concat_split_op_gpu.cc
│   │   ├── concat_split_op.h
│   │   ├── conditional_op.cc
│   │   ├── conditional_op.h
│   │   ├── conv_gradient_op.cc
│   │   ├── conv_op_cache_cudnn.cc
│   │   ├── conv_op_cache_cudnn.h
│   │   ├── conv_op_cache_cudnn_test.cc
│   │   ├── conv_op.cc
│   │   ├── conv_op_cudnn.cc
│   │   ├── conv_op_eigen.cc
│   │   ├── conv_op_gpu.cc
│   │   ├── conv_op.h
│   │   ├── conv_op_impl.h
│   │   ├── conv_op_shared.cc
│   │   ├── conv_op_shared_gpu.cc
│   │   ├── conv_op_shared.h
│   │   ├── conv_pool_op_base.h
│   │   ├── conv_transpose_gradient_op.cc
│   │   ├── conv_transpose_op.cc
│   │   ├── conv_transpose_op_cudnn.cc
│   │   ├── conv_transpose_op_gpu.cc
│   │   ├── conv_transpose_op.h
│   │   ├── 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
│   │   ├── cosine_embedding_criterion_op.cc
│   │   ├── cosine_embedding_criterion_op.cu
│   │   ├── cosine_embedding_criterion_op.h
│   │   ├── cos_op.cc
│   │   ├── cos_op.cu
│   │   ├── counter_ops.cc
│   │   ├── counter_ops_gpu.cc
│   │   ├── counter_ops.h
│   │   ├── 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_gpu.cc
│   │   ├── do_op.h
│   │   ├── dropout_op.cc
│   │   ├── dropout_op.cu
│   │   ├── dropout_op_cudnn.cc
│   │   ├── dropout_op.h
│   │   ├── 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_gpu_test.cc
│   │   ├── elementwise_op.h
│   │   ├── 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
│   │   ├── expand_squeeze_dims_op.cc
│   │   ├── expand_squeeze_dims_op_gpu.cc
│   │   ├── expand_squeeze_dims_op.h
│   │   ├── exp_op.cc
│   │   ├── exp_op.cu
│   │   ├── extend_tensor_op.cc
│   │   ├── feed_blob_op.cc
│   │   ├── feed_blob_op.h
│   │   ├── filler_op.cc
│   │   ├── filler_op.cu
│   │   ├── filler_op_gpu.cc
│   │   ├── filler_op.h
│   │   ├── 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_gpu.cc
│   │   ├── free_op.h
│   │   ├── fully_connected_op.cc
│   │   ├── fully_connected_op_gpu.cc
│   │   ├── fully_connected_op.h
│   │   ├── 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_gpu.cu
│   │   ├── gru_unit_op.h
│   │   ├── half_float_ops.cc
│   │   ├── half_float_ops.cu
│   │   ├── half_float_ops.h
│   │   ├── h_softmax_op.cc
│   │   ├── h_softmax_op.h
│   │   ├── if_op.cc
│   │   ├── if_op_gpu.cc
│   │   ├── if_op.h
│   │   ├── im2col_op.cc
│   │   ├── im2col_op_gpu.cc
│   │   ├── im2col_op.h
│   │   ├── 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_gpu.cc
│   │   ├── lengths_tile_op.h
│   │   ├── 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_gpu.cc
│   │   ├── load_save_op.h
│   │   ├── locally_connected_op.cc
│   │   ├── locally_connected_op_gpu.cc
│   │   ├── locally_connected_op.h
│   │   ├── locally_connected_op_impl.h
│   │   ├── locally_connected_op_util.cc
│   │   ├── locally_connected_op_util.h
│   │   ├── local_response_normalization_op.cc
│   │   ├── local_response_normalization_op.cu
│   │   ├── local_response_normalization_op_cudnn.cc
│   │   ├── local_response_normalization_op.h
│   │   ├── logit_op.cc
│   │   ├── logit_op.cu
│   │   ├── logit_op.h
│   │   ├── log_op.cc
│   │   ├── log_op.cu
│   │   ├── loss_op.cc
│   │   ├── loss_op.cu
│   │   ├── loss_op.h
│   │   ├── lpnorm_op.cc
│   │   ├── lpnorm_op.h
│   │   ├── lp_pool_op.cc
│   │   ├── lp_pool_op.cu
│   │   ├── lstm_unit_op.cc
│   │   ├── lstm_unit_op_gpu.cu
│   │   ├── lstm_unit_op.h
│   │   ├── 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_gpu.cc
│   │   ├── matmul_op.h
│   │   ├── 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_gpu.cc
│   │   ├── negate_gradient_op.h
│   │   ├── negative_op.cc
│   │   ├── negative_op.cu
│   │   ├── ngram_ops.cc
│   │   ├── ngram_ops.h
│   │   ├── no_default_engine_op.h
│   │   ├── normalize_l1_op.cc
│   │   ├── normalize_l1_op.h
│   │   ├── normalize_op.cc
│   │   ├── normalize_op.h
│   │   ├── normalize_ops.cu
│   │   ├── norm_planar_yuv_op.cc
│   │   ├── one_hot_ops.cc
│   │   ├── one_hot_ops.cu
│   │   ├── one_hot_ops.h
│   │   ├── onnx_while_op.cc
│   │   ├── onnx_while_op.h
│   │   ├── operator_fallback_gpu.h
│   │   ├── operator_fallback_gpu_test.cc
│   │   ├── op_utils_cudnn.h
│   │   ├── 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_gpu.cu
│   │   ├── pad_op.h
│   │   ├── 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_cudnn.cu
│   │   ├── pool_op.h
│   │   ├── 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_gpu.cc
│   │   ├── prepend_dim_op.h
│   │   ├── 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_gpu.cc
│   │   ├── recurrent_network_blob_fetcher_op.h
│   │   ├── recurrent_network_executor.cc
│   │   ├── recurrent_network_executor_gpu.cc
│   │   ├── recurrent_network_executor_gpu.h
│   │   ├── recurrent_network_executor.h
│   │   ├── recurrent_network_executor_incl.h
│   │   ├── recurrent_network_op.cc
│   │   ├── recurrent_network_op_gpu.cu
│   │   ├── recurrent_network_op.h
│   │   ├── 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_cudnn.cc
│   │   ├── relu_op_fp16.cu
│   │   ├── relu_op.h
│   │   ├── 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_gpu.cc
│   │   ├── reshape_op_gpu_test.cc
│   │   ├── reshape_op.h
│   │   ├── 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_gpu_test.cc
│   │   ├── roi_align_op.h
│   │   ├── roi_pool_op.cc
│   │   ├── roi_pool_op.cu
│   │   ├── roi_pool_op.h
│   │   ├── rowmul_op.cc
│   │   ├── rowmul_op.h
│   │   ├── scale_op.cc
│   │   ├── scale_op_gpu.cc
│   │   ├── scale_op.h
│   │   ├── segment_reduction_op.cc
│   │   ├── segment_reduction_op_gpu.cu
│   │   ├── segment_reduction_op.h
│   │   ├── selu_op.cc
│   │   ├── selu_op.cu
│   │   ├── selu_op.h
│   │   ├── sequence_ops.cc
│   │   ├── sequence_ops.cu
│   │   ├── sequence_ops.h
│   │   ├── shape_op.cc
│   │   ├── shape_op_gpu.cc
│   │   ├── shape_op.h
│   │   ├── 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_cudnn.cc
│   │   ├── softmax_op.h
│   │   ├── 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_gpu.cu
│   │   ├── space_batch_op.h
│   │   ├── 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_cudnn.cc
│   │   ├── spatial_batch_norm_op.h
│   │   ├── 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_gpu.cc
│   │   ├── stop_gradient.h
│   │   ├── 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_gpu.cc
│   │   ├── tensor_protos_db_input.h
│   │   ├── 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_cudnn.cc
│   │   ├── transpose_op.h
│   │   ├── tt_linear_op.cc
│   │   ├── tt_linear_op.h
│   │   ├── utility_ops.cc
│   │   ├── utility_ops.cu
│   │   ├── utility_ops_gpu.cc
│   │   ├── utility_ops_gpu_test.cc
│   │   ├── utility_ops.h
│   │   ├── 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_gpu.cc
│   │   ├── while_op.h
│   │   ├── workspace_ops.cc
│   │   ├── zero_gradient_op.cc
│   │   ├── zero_gradient_op_gpu.cc
│   │   └── zero_gradient_op.h
│   ├── perfkernels
│   │   ├── CMakeLists.txt
│   │   ├── common_avx2.cc
│   │   ├── common_avx.cc
│   │   ├── common.h
│   │   ├── cvtsh_ss_bugfix.h
│   │   ├── embedding_lookup_avx2.cc
│   │   ├── embedding_lookup.cc
│   │   ├── embedding_lookup_fused_8bit_rowwise_avx2.cc
│   │   ├── embedding_lookup.h
│   │   ├── fused_8bit_rowwise_embedding_lookup.cc
│   │   ├── fused_8bit_rowwise_embedding_lookup.h
│   │   ├── hp_emblookup_codegen.py
│   │   ├── typed_axpy_avx2.cc
│   │   ├── typed_axpy_avx.cc
│   │   ├── typed_axpy.cc
│   │   └── typed_axpy.h
│   ├── proto
│   │   ├── caffe2_legacy.proto
│   │   ├── caffe2.proto
│   │   ├── CMakeLists.txt
│   │   ├── hsm.proto
│   │   ├── __init__.py
│   │   ├── metanet.proto
│   │   ├── predictor_consts.proto
│   │   └── prof_dag.proto
│   ├── python
│   │   ├── 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
│   │   ├── CMakeLists.txt
│   │   ├── cnn.py
│   │   ├── context.py
│   │   ├── context_test.py
│   │   ├── control_ops_grad.py
│   │   ├── control_ops_util.py
│   │   ├── control.py
│   │   ├── control_test.py
│   │   ├── convnet_benchmarks.py
│   │   ├── convnet_benchmarks_test.py
│   │   ├── core_gradients_test.py
│   │   ├── core.py
│   │   ├── core_test.py
│   │   ├── crf.py
│   │   ├── dataio.py
│   │   ├── dataio_test.py
│   │   ├── data_parallel_model.py
│   │   ├── data_parallel_model_test.py
│   │   ├── data_parallel_model_utils.py
│   │   ├── dataset.py
│   │   ├── data_workers.py
│   │   ├── data_workers_test.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_checker.py
│   │   ├── gradient_check_test.py
│   │   ├── gru_cell.py
│   │   ├── helpers
│   │   │   ├── algebra.py
│   │   │   ├── arg_scope.py
│   │   │   ├── array_helpers.py
│   │   │   ├── control_ops.py
│   │   │   ├── conv.py
│   │   │   ├── db_input.py
│   │   │   ├── dropout.py
│   │   │   ├── elementwise_linear.py
│   │   │   ├── fc.py
│   │   │   ├── __init__.py
│   │   │   ├── nonlinearity.py
│   │   │   ├── normalization.py
│   │   │   ├── pooling.py
│   │   │   ├── tools.py
│   │   │   └── train.py
│   │   ├── hsm_util.py
│   │   ├── hypothesis_test.py
│   │   ├── hypothesis_test_util.py
│   │   ├── _import_c_extension.py
│   │   ├── __init__.py
│   │   ├── layer_model_helper.py
│   │   ├── layer_model_instantiator.py
│   │   ├── layer_parameter_sharing_test.py
│   │   ├── layers
│   │   │   ├── 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
│   │   │   ├── build_index.py
│   │   │   ├── concat.py
│   │   │   ├── conv.py
│   │   │   ├── dropout.py
│   │   │   ├── fc.py
│   │   │   ├── fc_without_bias.py
│   │   │   ├── feature_sparse_to_dense.py
│   │   │   ├── functional.py
│   │   │   ├── gather_record.py
│   │   │   ├── __init__.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_trainable_mixin.py
│   │   │   ├── sampling_train.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
│   │   ├── layer_test_util.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_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_LRN_op_test.py
│   │   │   ├── mkl_LRN_speed_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
│   │   │   ├── 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
│   │   │   ├── __init__.py
│   │   │   ├── net_modifier.py
│   │   │   ├── parameter_info.py
│   │   │   ├── parameter_sharing.py
│   │   │   └── parameter_sharing_test.py
│   │   ├── models
│   │   │   ├── download.py
│   │   │   ├── __init__.py
│   │   │   ├── resnet.py
│   │   │   ├── resnet_test.py
│   │   │   ├── seq2seq
│   │   │   │   ├── beam_search.py
│   │   │   │   ├── __init__.py
│   │   │   │   ├── seq2seq_beam_search_test.py
│   │   │   │   ├── seq2seq_model_helper.py
│   │   │   │   ├── seq2seq_model_helper_test.py
│   │   │   │   ├── seq2seq_util.py
│   │   │   │   ├── train.py
│   │   │   │   └── translate.py
│   │   │   └── __sym_init__.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
│   │   │   ├── backend_cpp_rep.py
│   │   │   ├── backend.py
│   │   │   ├── backend_rep.py
│   │   │   ├── bin
│   │   │   │   ├── conversion.py
│   │   │   │   └── __init__.py
│   │   │   ├── error.py
│   │   │   ├── frontend.py
│   │   │   ├── helper.py
│   │   │   ├── __init__.py
│   │   │   ├── ONNXOpCoverage.md
│   │   │   ├── README.md
│   │   │   ├── tests
│   │   │   │   ├── c2_ref_test.py
│   │   │   │   ├── conversion_test.py
│   │   │   │   ├── helper_test.py
│   │   │   │   ├── __init__.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_context.py
│   │   ├── optimizer.py
│   │   ├── optimizer_test.py
│   │   ├── optimizer_test_util.py
│   │   ├── parallelize_bmuf_distributed_test.py
│   │   ├── parallel_workers.py
│   │   ├── parallel_workers_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_dlpack.cc
│   │   ├── pybind_state_dlpack.h
│   │   ├── pybind_state_gpu.cc
│   │   ├── pybind_state.h
│   │   ├── pybind_state_mkl.cc
│   │   ├── python_op_test.py
│   │   ├── queue_util.py
│   │   ├── record_queue.py
│   │   ├── recurrent.py
│   │   ├── regularizer_context.py
│   │   ├── regularizer.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
│   │   │   ├── create_your_own_dataset.ipynb
│   │   │   ├── experimental
│   │   │   │   └── Immediate.ipynb
│   │   │   ├── Getting_Caffe1_Models_for_Translation.ipynb
│   │   │   ├── helpers.py
│   │   │   ├── Image_Pre-Processing_Pipeline.ipynb
│   │   │   ├── images
│   │   │   │   ├── aircraft-carrier.jpg
│   │   │   │   ├── astronauts.jpg
│   │   │   │   ├── cat.jpg
│   │   │   │   ├── Cellsx128.png
│   │   │   │   ├── cell-tower.jpg
│   │   │   │   ├── cowboy-hat.jpg
│   │   │   │   ├── Ducreux.jpg
│   │   │   │   ├── Flower-id.png
│   │   │   │   ├── flower.jpg
│   │   │   │   ├── imagenet-boat.png
│   │   │   │   ├── imagenet-caffe2.png
│   │   │   │   ├── imagenet-meme.jpg
│   │   │   │   ├── imagenet-montage.jpg
│   │   │   │   ├── lemon.jpg
│   │   │   │   ├── mirror-image.jpg
│   │   │   │   ├── orange.jpg
│   │   │   │   ├── orangutan.jpg
│   │   │   │   ├── Places-cnn-visual-example.png
│   │   │   │   ├── pretzel.jpg
│   │   │   │   └── sickle-cells.jpg
│   │   │   ├── inference_codes.txt
│   │   │   ├── jupyter_notebook_config.py
│   │   │   ├── Loading_Pretrained_Models.ipynb
│   │   │   ├── MNIST_Dataset_and_Databases.ipynb
│   │   │   ├── MNIST.ipynb
│   │   │   ├── Model_Quickload.ipynb
│   │   │   ├── Multi-GPU_Training.ipynb
│   │   │   ├── py_gen
│   │   │   │   ├── Basics.py
│   │   │   │   ├── Control_Ops.py
│   │   │   │   ├── create_your_own_dataset.py
│   │   │   │   ├── Getting_Caffe1_Models_for_Translation.py
│   │   │   │   ├── Image_Pre-Processing_Pipeline.py
│   │   │   │   ├── Loading_Pretrained_Models.py
│   │   │   │   ├── MNIST_Dataset_and_Databases.py
│   │   │   │   ├── MNIST.py
│   │   │   │   ├── Model_Quickload.py
│   │   │   │   ├── Multi-GPU_Training.py
│   │   │   │   ├── Python_Op.py
│   │   │   │   ├── sparseNN.py
│   │   │   │   ├── Toy_Regression.py
│   │   │   │   └── Training_a_Model.py
│   │   │   ├── Python_Op.ipynb
│   │   │   ├── README.md
│   │   │   ├── start_ipython_notebook.sh
│   │   │   ├── Toy_Regression.ipynb
│   │   │   ├── Training_a_Model.ipynb
│   │   │   └── tutorials_to_script_converter.py
│   │   ├── utils.py
│   │   ├── visualize.py
│   │   ├── workspace.py
│   │   └── workspace_test.py
│   ├── queue
│   │   ├── blobs_queue.cc
│   │   ├── blobs_queue_db.cc
│   │   ├── blobs_queue_db.h
│   │   ├── blobs_queue.h
│   │   ├── CMakeLists.txt
│   │   ├── queue_ops.cc
│   │   ├── queue_ops_gpu.cc
│   │   ├── queue_ops.h
│   │   ├── rebatching_queue.cc
│   │   ├── rebatching_queue.h
│   │   ├── rebatching_queue_ops.cc
│   │   └── rebatching_queue_ops.h
│   ├── sgd
│   │   ├── adagrad_op.cc
│   │   ├── adagrad_op_gpu.cu
│   │   ├── adagrad_op.h
│   │   ├── adam_op.cc
│   │   ├── adam_op_gpu.cu
│   │   ├── adam_op.h
│   │   ├── clip_tensor_op.cc
│   │   ├── clip_tensor_op.h
│   │   ├── CMakeLists.txt
│   │   ├── 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_gpu.cc
│   │   ├── iter_op.h
│   │   ├── lars_op.cc
│   │   ├── lars_op_gpu.cu
│   │   ├── lars_op.h
│   │   ├── learning_rate_functors.h
│   │   ├── learning_rate_op.cc
│   │   ├── learning_rate_op_gpu.cc
│   │   ├── learning_rate_op.h
│   │   ├── momentum_sgd_op.cc
│   │   ├── momentum_sgd_op_gpu.cu
│   │   ├── momentum_sgd_op.h
│   │   ├── rmsprop_op.cc
│   │   ├── rmsprop_op_gpu.cu
│   │   ├── rmsprop_op.h
│   │   ├── yellowfin_op.cc
│   │   ├── yellowfin_op_gpu.cu
│   │   └── yellowfin_op.h
│   ├── 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
│   │   ├── cast.h
│   │   ├── cblas.h
│   │   ├── CMakeLists.txt
│   │   ├── conversions.h
│   │   ├── cpuid.cc
│   │   ├── cpuid.h
│   │   ├── cpuid_test.cc
│   │   ├── cpu_neon.h
│   │   ├── eigen_utils.h
│   │   ├── fatal_signal_asan_no_sig_test.cc
│   │   ├── fixed_divisor.h
│   │   ├── fixed_divisor_test.cc
│   │   ├── GpuBitonicSort.cuh
│   │   ├── GpuDefs.cuh
│   │   ├── GpuScanUtils.cuh
│   │   ├── math_cpu.cc
│   │   ├── math-detail.h
│   │   ├── math_gpu.cu
│   │   ├── math_gpu_test.cc
│   │   ├── math.h
│   │   ├── 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
│   │   ├── threadpool
│   │   │   ├── pthreadpool.cc
│   │   │   ├── pthreadpool.h
│   │   │   ├── pthreadpool_impl.cc
│   │   │   ├── pthreadpool_impl.h
│   │   │   ├── ThreadPool.cc
│   │   │   ├── ThreadPoolCommon.h
│   │   │   ├── ThreadPool.h
│   │   │   └── WorkersPool.h
│   │   ├── thread_pool.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_gpu.cc
│   ├── video_input_op.h
│   ├── video_io.cc
│   └── video_io.h
├── cmake
│   ├── BuildVariables.cmake
│   ├── Caffe2Config.cmake.in
│   ├── Caffe2ConfigVersion.cmake.in
│   ├── cmake_uninstall.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
│   │   ├── FindLevelDB.cmake
│   │   ├── FindLMDB.cmake
│   │   ├── FindMatlabMex.cmake
│   │   ├── FindMKL.cmake
│   │   ├── FindNCCL.cmake
│   │   ├── FindNNPACK.cmake
│   │   ├── FindNuma.cmake
│   │   ├── FindNumPy.cmake
│   │   ├── FindOpenBLAS.cmake
│   │   ├── Findpybind11.cmake
│   │   ├── FindRocksDB.cmake
│   │   ├── FindSnappy.cmake
│   │   ├── FindvecLib.cmake
│   │   └── FindZMQ.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
│   ├── public
│   │   ├── cuda.cmake
│   │   ├── gflags.cmake
│   │   ├── glog.cmake
│   │   ├── protobuf.cmake
│   │   ├── threads.cmake
│   │   └── utils.cmake
│   ├── Summary.cmake
│   ├── Utils.cmake
│   └── Whitelist.cmake
├── CMakeLists.txt
├── 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
│   │   ├── build.sh
│   │   ├── centos
│   │   │   └── Dockerfile
│   │   ├── centos-cuda
│   │   │   └── 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
│   │   ├── README.md
│   │   ├── ubuntu
│   │   │   └── Dockerfile
│   │   └── ubuntu-cuda
│   │   └── 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
│   ├── Caffe2-with-name-55-tall.png
│   ├── DoxygenLayout-c.xml
│   ├── DoxygenLayout-python.xml
│   ├── DOXYGEN.md
│   ├── footer.html
│   ├── header.html
│   ├── installation.md
│   ├── main.css
│   ├── process.py
│   ├── README.md
│   └── stylesheet.css
├── LICENSE
├── Makefile
├── modules
│   ├── CMakeLists.txt
│   ├── detectron
│   │   ├── affine_channel_op.cc
│   │   ├── affine_channel_op.cu
│   │   ├── affine_channel_op.h
│   │   ├── batch_permutation_op.cc
│   │   ├── batch_permutation_op.cu
│   │   ├── batch_permutation_op.h
│   │   ├── CMakeLists.txt
│   │   ├── 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
├── NOTICE
├── README.md
├── release-notes.md
├── scripts
│   ├── add_apache_header.sh
│   ├── apache_header.txt
│   ├── appveyor
│   │   ├── install.bat
│   │   └── install_cuda.bat
│   ├── build_anaconda.sh
│   ├── build_android.sh
│   ├── build_host_protoc.sh
│   ├── build_ios.sh
│   ├── build_local.sh
│   ├── build_raspbian.sh
│   ├── build_tegra_x1.sh
│   ├── build_tizen.sh
│   ├── build_windows.bat
│   ├── diagnose_protobuf.py
│   ├── get_python_cmake_flags.py
│   ├── read_conda_versions.sh
│   ├── start_ipython_notebook.sh
│   └── temp.sh
├── setup.py
└── VERSION_NUMBER

153 directories, 1945 files