Full Code of eric612/Caffe-YOLOv3-Windows for AI

gitextract_w8y_2sfa/

├── .Doxyfile
├── .gitattributes
├── .gitignore
├── .gitmodules
├── .travis.yml
├── CMakeLists.txt
├── CONTRIBUTING.md
├── CONTRIBUTORS.md
├── INSTALL.md
├── LICENSE
├── Makefile
├── Makefile.config.example
├── README.md
├── appveyor.yml
├── caffe.cloc
├── cmake/
│   ├── CaffeGetPrerequisites.cmake
│   ├── ConfigGen.cmake
│   ├── Cuda.cmake
│   ├── Dependencies.cmake
│   ├── External/
│   │   ├── gflags.cmake
│   │   ├── glog.cmake
│   │   └── nccl.cmake
│   ├── Misc.cmake
│   ├── Modules/
│   │   ├── FindAtlas.cmake
│   │   ├── FindGFlags.cmake
│   │   ├── FindGlog.cmake
│   │   ├── FindLAPACK.cmake
│   │   ├── FindLMDB.cmake
│   │   ├── FindLevelDB.cmake
│   │   ├── FindMKL.cmake
│   │   ├── FindMatlabMex.cmake
│   │   ├── FindNCCL.cmake
│   │   ├── FindNumPy.cmake
│   │   ├── FindOpenBLAS.cmake
│   │   ├── FindSnappy.cmake
│   │   └── FindvecLib.cmake
│   ├── ProtoBuf.cmake
│   ├── Summary.cmake
│   ├── TargetResolvePrerequesites.cmake
│   ├── Targets.cmake
│   ├── Templates/
│   │   ├── CaffeConfig.cmake.in
│   │   ├── CaffeConfigVersion.cmake.in
│   │   ├── caffe_config.h.in
│   │   └── export.hpp.in
│   ├── Uninstall.cmake.in
│   ├── Utils.cmake
│   ├── WindowsCreateLinkHeader.cmake
│   ├── WindowsDownloadPrebuiltDependencies.cmake
│   └── lint.cmake
├── data/
│   ├── cifar10/
│   │   └── get_cifar10.sh
│   ├── ilsvrc12/
│   │   └── get_ilsvrc_aux.sh
│   └── mnist/
│       ├── get_mnist.ps1
│       └── get_mnist.sh
├── docker/
│   ├── README.md
│   ├── cpu/
│   │   └── Dockerfile
│   └── gpu/
│       └── Dockerfile
├── docs/
│   ├── CMakeLists.txt
│   ├── CNAME
│   ├── README.md
│   ├── _config.yml
│   ├── _layouts/
│   │   └── default.html
│   ├── development.md
│   ├── index.md
│   ├── install_apt.md
│   ├── install_apt_debian.md
│   ├── install_osx.md
│   ├── install_yum.md
│   ├── installation.md
│   ├── model_zoo.md
│   ├── multigpu.md
│   ├── stylesheets/
│   │   ├── pygment_trac.css
│   │   ├── reset.css
│   │   └── styles.css
│   └── tutorial/
│       ├── convolution.md
│       ├── data.md
│       ├── fig/
│       │   └── .gitignore
│       ├── forward_backward.md
│       ├── index.md
│       ├── interfaces.md
│       ├── layers/
│       │   ├── absval.md
│       │   ├── accuracy.md
│       │   ├── argmax.md
│       │   ├── batchnorm.md
│       │   ├── batchreindex.md
│       │   ├── bias.md
│       │   ├── bnll.md
│       │   ├── concat.md
│       │   ├── contrastiveloss.md
│       │   ├── convolution.md
│       │   ├── crop.md
│       │   ├── data.md
│       │   ├── deconvolution.md
│       │   ├── dropout.md
│       │   ├── dummydata.md
│       │   ├── eltwise.md
│       │   ├── elu.md
│       │   ├── embed.md
│       │   ├── euclideanloss.md
│       │   ├── exp.md
│       │   ├── filter.md
│       │   ├── flatten.md
│       │   ├── hdf5data.md
│       │   ├── hdf5output.md
│       │   ├── hingeloss.md
│       │   ├── im2col.md
│       │   ├── imagedata.md
│       │   ├── infogainloss.md
│       │   ├── innerproduct.md
│       │   ├── input.md
│       │   ├── lrn.md
│       │   ├── lstm.md
│       │   ├── memorydata.md
│       │   ├── multinomiallogisticloss.md
│       │   ├── mvn.md
│       │   ├── parameter.md
│       │   ├── pooling.md
│       │   ├── power.md
│       │   ├── prelu.md
│       │   ├── python.md
│       │   ├── recurrent.md
│       │   ├── reduction.md
│       │   ├── relu.md
│       │   ├── reshape.md
│       │   ├── rnn.md
│       │   ├── scale.md
│       │   ├── sigmoid.md
│       │   ├── sigmoidcrossentropyloss.md
│       │   ├── silence.md
│       │   ├── slice.md
│       │   ├── softmax.md
│       │   ├── softmaxwithloss.md
│       │   ├── split.md
│       │   ├── spp.md
│       │   ├── tanh.md
│       │   ├── threshold.md
│       │   ├── tile.md
│       │   └── windowdata.md
│       ├── layers.md
│       ├── loss.md
│       ├── net_layer_blob.md
│       └── solver.md
├── examples/
│   ├── 00-classification.ipynb
│   ├── 01-learning-lenet.ipynb
│   ├── 02-fine-tuning.ipynb
│   ├── CMakeLists.txt
│   ├── brewing-logreg.ipynb
│   ├── cifar10/
│   │   ├── cifar10_full.prototxt
│   │   ├── cifar10_full_sigmoid_solver.prototxt
│   │   ├── cifar10_full_sigmoid_solver_bn.prototxt
│   │   ├── cifar10_full_sigmoid_train_test.prototxt
│   │   ├── cifar10_full_sigmoid_train_test_bn.prototxt
│   │   ├── cifar10_full_solver.prototxt
│   │   ├── cifar10_full_solver_lr1.prototxt
│   │   ├── cifar10_full_solver_lr2.prototxt
│   │   ├── cifar10_full_train_test.prototxt
│   │   ├── cifar10_quick.prototxt
│   │   ├── cifar10_quick_solver.prototxt
│   │   ├── cifar10_quick_solver_lr1.prototxt
│   │   ├── cifar10_quick_train_test.prototxt
│   │   ├── convert_cifar_data.cpp
│   │   ├── create_cifar10.sh
│   │   ├── readme.md
│   │   ├── train_full.sh
│   │   ├── train_full_sigmoid.sh
│   │   ├── train_full_sigmoid_bn.sh
│   │   └── train_quick.sh
│   ├── cpp_classification/
│   │   ├── classification.cpp
│   │   └── readme.md
│   ├── demo_darknet19.cmd
│   ├── demo_darknet19_voc.cmd
│   ├── demo_yolo.cmd
│   ├── demo_yolo_lite.cmd
│   ├── detection.ipynb
│   ├── feature_extraction/
│   │   ├── imagenet_val.prototxt
│   │   └── readme.md
│   ├── finetune_flickr_style/
│   │   ├── assemble_data.py
│   │   ├── readme.md
│   │   └── style_names.txt
│   ├── finetune_pascal_detection/
│   │   ├── pascal_finetune_solver.prototxt
│   │   └── pascal_finetune_trainval_test.prototxt
│   ├── hdf5_classification/
│   │   ├── nonlinear_auto_test.prototxt
│   │   ├── nonlinear_auto_train.prototxt
│   │   ├── nonlinear_train_val.prototxt
│   │   └── train_val.prototxt
│   ├── imagenet/
│   │   ├── create_imagenet.sh
│   │   ├── make_imagenet_mean.sh
│   │   ├── readme.md
│   │   ├── resume_training.sh
│   │   └── train_caffenet.sh
│   ├── mnist/
│   │   ├── convert_mnist_data.cpp
│   │   ├── create_mnist.ps1
│   │   ├── create_mnist.sh
│   │   ├── lenet.prototxt
│   │   ├── lenet_adadelta_solver.prototxt
│   │   ├── lenet_auto_solver.prototxt
│   │   ├── lenet_consolidated_solver.prototxt
│   │   ├── lenet_multistep_solver.prototxt
│   │   ├── lenet_solver.prototxt
│   │   ├── lenet_solver_adam.prototxt
│   │   ├── lenet_solver_rmsprop.prototxt
│   │   ├── lenet_train_test.prototxt
│   │   ├── mnist_autoencoder.prototxt
│   │   ├── mnist_autoencoder_solver.prototxt
│   │   ├── mnist_autoencoder_solver_adadelta.prototxt
│   │   ├── mnist_autoencoder_solver_adagrad.prototxt
│   │   ├── mnist_autoencoder_solver_nesterov.prototxt
│   │   ├── readme.md
│   │   ├── train_lenet.ps1
│   │   ├── train_lenet.sh
│   │   ├── train_lenet_adam.sh
│   │   ├── train_lenet_consolidated.sh
│   │   ├── train_lenet_docker.sh
│   │   ├── train_lenet_rmsprop.sh
│   │   ├── train_mnist_autoencoder.sh
│   │   ├── train_mnist_autoencoder_adadelta.sh
│   │   ├── train_mnist_autoencoder_adagrad.sh
│   │   └── train_mnist_autoencoder_nesterov.sh
│   ├── net_surgery/
│   │   ├── bvlc_caffenet_full_conv.prototxt
│   │   └── conv.prototxt
│   ├── net_surgery.ipynb
│   ├── pascal-multilabel-with-datalayer.ipynb
│   ├── pycaffe/
│   │   ├── caffenet.py
│   │   ├── layers/
│   │   │   ├── pascal_multilabel_datalayers.py
│   │   │   └── pyloss.py
│   │   ├── linreg.prototxt
│   │   └── tools.py
│   ├── siamese/
│   │   ├── convert_mnist_siamese_data.cpp
│   │   ├── create_mnist_siamese.sh
│   │   ├── mnist_siamese.ipynb
│   │   ├── mnist_siamese.prototxt
│   │   ├── mnist_siamese_solver.prototxt
│   │   ├── mnist_siamese_train_test.prototxt
│   │   ├── readme.md
│   │   └── train_mnist_siamese.sh
│   ├── ssd/
│   │   ├── plot_detections.py
│   │   ├── score_ssd_coco.py
│   │   ├── score_ssd_pascal.py
│   │   ├── ssd_coco.py
│   │   ├── ssd_detect.cpp
│   │   ├── ssd_ilsvrc.py
│   │   ├── ssd_pascal.py
│   │   ├── ssd_pascal_orig.py
│   │   ├── ssd_pascal_resnet.py
│   │   ├── ssd_pascal_speed.py
│   │   ├── ssd_pascal_video.py
│   │   ├── ssd_pascal_webcam.py
│   │   ├── ssd_pascal_zf.py
│   │   └── test_ssd.py
│   ├── train_yolo.cmd
│   ├── train_yolo_darknet.cmd
│   ├── train_yolo_lite.cmd
│   ├── train_yolov3_lite.cmd
│   └── web_demo/
│       ├── app.py
│       ├── exifutil.py
│       ├── readme.md
│       ├── requirements.txt
│       └── templates/
│           └── index.html
├── include/
│   └── caffe/
│       ├── blob.hpp
│       ├── caffe.hpp
│       ├── common.hpp
│       ├── data_reader.hpp
│       ├── data_transformer.hpp
│       ├── filler.hpp
│       ├── internal_thread.hpp
│       ├── layer.hpp
│       ├── layer_factory.hpp
│       ├── layers/
│       │   ├── absval_layer.hpp
│       │   ├── accuracy_layer.hpp
│       │   ├── annotated_data_layer.hpp
│       │   ├── argmax_layer.hpp
│       │   ├── base_conv_layer.hpp
│       │   ├── base_data_layer.hpp
│       │   ├── batch_norm_layer.hpp
│       │   ├── batch_reindex_layer.hpp
│       │   ├── bias_layer.hpp
│       │   ├── bnll_layer.hpp
│       │   ├── concat_layer.hpp
│       │   ├── contrastive_loss_layer.hpp
│       │   ├── conv_layer.hpp
│       │   ├── crop_layer.hpp
│       │   ├── cudnn_conv_layer.hpp
│       │   ├── cudnn_lcn_layer.hpp
│       │   ├── cudnn_lrn_layer.hpp
│       │   ├── cudnn_pooling_layer.hpp
│       │   ├── cudnn_relu_layer.hpp
│       │   ├── cudnn_sigmoid_layer.hpp
│       │   ├── cudnn_softmax_layer.hpp
│       │   ├── cudnn_tanh_layer.hpp
│       │   ├── data_layer.hpp
│       │   ├── deconv_layer.hpp
│       │   ├── depthwise_conv_layer.hpp
│       │   ├── detection_evaluate_layer.hpp
│       │   ├── dropout_layer.hpp
│       │   ├── dummy_data_layer.hpp
│       │   ├── eltwise_layer.hpp
│       │   ├── elu_layer.hpp
│       │   ├── embed_layer.hpp
│       │   ├── euclidean_loss_layer.hpp
│       │   ├── exp_layer.hpp
│       │   ├── filter_layer.hpp
│       │   ├── flatten_layer.hpp
│       │   ├── hdf5_data_layer.hpp
│       │   ├── hdf5_output_layer.hpp
│       │   ├── hinge_loss_layer.hpp
│       │   ├── im2col_layer.hpp
│       │   ├── image_data_layer.hpp
│       │   ├── infogain_loss_layer.hpp
│       │   ├── inner_product_layer.hpp
│       │   ├── input_layer.hpp
│       │   ├── loss_layer.hpp
│       │   ├── lrn_layer.hpp
│       │   ├── lstm_layer.hpp
│       │   ├── memory_data_layer.hpp
│       │   ├── multinomial_logistic_loss_layer.hpp
│       │   ├── mvn_layer.hpp
│       │   ├── neuron_layer.hpp
│       │   ├── normalize_layer.hpp
│       │   ├── parameter_layer.hpp
│       │   ├── pooling_layer.hpp
│       │   ├── power_layer.hpp
│       │   ├── prelu_layer.hpp
│       │   ├── python_layer.hpp
│       │   ├── recurrent_layer.hpp
│       │   ├── reduction_layer.hpp
│       │   ├── region_loss_layer.hpp
│       │   ├── relu6_layer.hpp
│       │   ├── relu_layer.hpp
│       │   ├── reorg_layer.hpp
│       │   ├── reshape_layer.hpp
│       │   ├── rnn_layer.hpp
│       │   ├── scale_layer.hpp
│       │   ├── sigmoid_cross_entropy_loss_layer.hpp
│       │   ├── sigmoid_layer.hpp
│       │   ├── silence_layer.hpp
│       │   ├── slice_layer.hpp
│       │   ├── smooth_L1_loss_layer.hpp
│       │   ├── softmax_layer.hpp
│       │   ├── softmax_loss_layer.hpp
│       │   ├── split_layer.hpp
│       │   ├── spp_layer.hpp
│       │   ├── tanh_layer.hpp
│       │   ├── threshold_layer.hpp
│       │   ├── tile_layer.hpp
│       │   ├── window_data_layer.hpp
│       │   ├── yolo_detection_output_layer.hpp
│       │   ├── yolov3_detection_output_layer.hpp
│       │   └── yolov3_layer.hpp
│       ├── net.hpp
│       ├── parallel.hpp
│       ├── sgd_solvers.hpp
│       ├── solver.hpp
│       ├── solver_factory.hpp
│       ├── syncedmem.hpp
│       ├── test/
│       │   ├── test_caffe_main.hpp
│       │   └── test_gradient_check_util.hpp
│       └── util/
│           ├── bbox_util.hpp
│           ├── benchmark.hpp
│           ├── blocking_queue.hpp
│           ├── cudnn.hpp
│           ├── db.hpp
│           ├── db_leveldb.hpp
│           ├── db_lmdb.hpp
│           ├── device_alternate.hpp
│           ├── format.hpp
│           ├── gpu_util.cuh
│           ├── hdf5.hpp
│           ├── im2col.hpp
│           ├── im_transforms.hpp
│           ├── insert_splits.hpp
│           ├── io.hpp
│           ├── math_functions.hpp
│           ├── mkl_alternate.hpp
│           ├── nccl.hpp
│           ├── rng.hpp
│           ├── sampler.hpp
│           ├── signal_handler.h
│           └── upgrade_proto.hpp
├── matlab/
│   ├── +caffe/
│   │   ├── +test/
│   │   │   ├── test_io.m
│   │   │   ├── test_net.m
│   │   │   └── test_solver.m
│   │   ├── Blob.m
│   │   ├── Layer.m
│   │   ├── Net.m
│   │   ├── Solver.m
│   │   ├── get_net.m
│   │   ├── get_solver.m
│   │   ├── imagenet/
│   │   │   └── ilsvrc_2012_mean.mat
│   │   ├── io.m
│   │   ├── private/
│   │   │   ├── CHECK.m
│   │   │   ├── CHECK_FILE_EXIST.m
│   │   │   ├── caffe_.cpp
│   │   │   └── is_valid_handle.m
│   │   ├── reset_all.m
│   │   ├── run_tests.m
│   │   ├── set_device.m
│   │   ├── set_mode_cpu.m
│   │   ├── set_mode_gpu.m
│   │   └── version.m
│   ├── CMakeLists.txt
│   ├── demo/
│   │   └── classification_demo.m
│   └── hdf5creation/
│       ├── .gitignore
│       ├── demo.m
│       └── store2hdf5.m
├── models/
│   ├── bvlc_alexnet/
│   │   ├── deploy.prototxt
│   │   ├── readme.md
│   │   ├── solver.prototxt
│   │   └── train_val.prototxt
│   ├── bvlc_googlenet/
│   │   ├── deploy.prototxt
│   │   ├── quick_solver.prototxt
│   │   ├── readme.md
│   │   ├── solver.prototxt
│   │   └── train_val.prototxt
│   ├── bvlc_reference_caffenet/
│   │   ├── deploy.prototxt
│   │   ├── readme.md
│   │   ├── solver.prototxt
│   │   └── train_val.prototxt
│   ├── bvlc_reference_rcnn_ilsvrc13/
│   │   ├── deploy.prototxt
│   │   └── readme.md
│   ├── convert/
│   │   ├── .gitignore
│   │   ├── darknet19_conv23.prototxt
│   │   ├── darknet19_deploy.prototxt
│   │   ├── darknet19_voc_deploy.prototxt
│   │   └── weights_to_prototxt.py
│   ├── darknet/
│   │   ├── README.md
│   │   ├── darknet19_deploy.prototxt
│   │   ├── darknet19_solver.prototxt
│   │   ├── darknet19_test.prototxt
│   │   └── darknet19_train.prototxt
│   ├── finetune_flickr_style/
│   │   ├── deploy.prototxt
│   │   ├── readme.md
│   │   ├── solver.prototxt
│   │   └── train_val.prototxt
│   ├── yolov2/
│   │   ├── mobilenet_yolo_deploy.prototxt
│   │   ├── mobilenet_yolo_lite_deploy.prototxt
│   │   ├── mobilenet_yolo_lite_solver.prototxt
│   │   ├── mobilenet_yolo_lite_test.prototxt
│   │   ├── mobilenet_yolo_lite_train.prototxt
│   │   ├── mobilenet_yolo_solver.prototxt
│   │   ├── mobilenet_yolo_test.prototxt
│   │   └── mobilenet_yolo_train.prototxt
│   ├── yolov3/
│   │   ├── mobilenet_yolov3_lite_deploy.prototxt
│   │   ├── mobilenet_yolov3_lite_solver.prototxt
│   │   ├── mobilenet_yolov3_lite_test.prototxt
│   │   ├── mobilenet_yolov3_lite_train.prototxt
│   │   ├── mobilenet_yolov3_solver.prototxt
│   │   ├── mobilenet_yolov3_test.prototxt
│   │   └── mobilenet_yolov3_train.prototxt
│   └── yolov3_coco/
│       ├── mobilenet_yolov3_solver.prototxt
│       ├── mobilenet_yolov3_test.prototxt
│       └── mobilenet_yolov3_train.prototxt
├── python/
│   ├── CMakeLists.txt
│   ├── caffe/
│   │   ├── __init__.py
│   │   ├── _caffe.cpp
│   │   ├── classifier.py
│   │   ├── coord_map.py
│   │   ├── detector.py
│   │   ├── draw.py
│   │   ├── imagenet/
│   │   │   └── ilsvrc_2012_mean.npy
│   │   ├── io.py
│   │   ├── net_spec.py
│   │   ├── pycaffe.py
│   │   └── test/
│   │       ├── test_coord_map.py
│   │       ├── test_draw.py
│   │       ├── test_io.py
│   │       ├── test_layer_type_list.py
│   │       ├── test_nccl.py
│   │       ├── test_net.py
│   │       ├── test_net_spec.py
│   │       ├── test_python_layer.py
│   │       ├── test_python_layer_with_param_str.py
│   │       └── test_solver.py
│   ├── classify.py
│   ├── detect.py
│   ├── draw_net.py
│   ├── requirements.txt
│   └── train.py
├── scripts/
│   ├── appveyor/
│   │   └── appveyor_install_cuda.cmd
│   ├── build_docs.sh
│   ├── build_win.cmd
│   ├── caffe
│   ├── copy_notebook.py
│   ├── cpp_lint.py
│   ├── deploy_docs.sh
│   ├── download_model_binary.py
│   ├── download_model_from_gist.sh
│   ├── download_prebuilt_dependencies.py
│   ├── gather_examples.sh
│   ├── split_caffe_proto.py
│   ├── travis/
│   │   ├── build.sh
│   │   ├── configure-cmake.sh
│   │   ├── configure-make.sh
│   │   ├── configure.sh
│   │   ├── defaults.sh
│   │   ├── install-deps.sh
│   │   ├── install-python-deps.sh
│   │   ├── setup-venv.sh
│   │   └── test.sh
│   └── upload_model_to_gist.sh
├── src/
│   ├── caffe/
│   │   ├── CMakeLists.txt
│   │   ├── blob.cpp
│   │   ├── common.cpp
│   │   ├── data_reader.cpp
│   │   ├── data_transformer.cpp
│   │   ├── internal_thread.cpp
│   │   ├── layer.cpp
│   │   ├── layer_factory.cpp
│   │   ├── layers/
│   │   │   ├── absval_layer.cpp
│   │   │   ├── absval_layer.cu
│   │   │   ├── accuracy_layer.cpp
│   │   │   ├── annotated_data_layer.cpp
│   │   │   ├── argmax_layer.cpp
│   │   │   ├── base_conv_layer.cpp
│   │   │   ├── base_data_layer.cpp
│   │   │   ├── base_data_layer.cu
│   │   │   ├── batch_norm_layer.cpp
│   │   │   ├── batch_norm_layer.cu
│   │   │   ├── batch_reindex_layer.cpp
│   │   │   ├── batch_reindex_layer.cu
│   │   │   ├── bias_layer.cpp
│   │   │   ├── bias_layer.cu
│   │   │   ├── bnll_layer.cpp
│   │   │   ├── bnll_layer.cu
│   │   │   ├── concat_layer.cpp
│   │   │   ├── concat_layer.cu
│   │   │   ├── contrastive_loss_layer.cpp
│   │   │   ├── contrastive_loss_layer.cu
│   │   │   ├── conv_layer.cpp
│   │   │   ├── conv_layer.cu
│   │   │   ├── crop_layer.cpp
│   │   │   ├── crop_layer.cu
│   │   │   ├── cudnn_conv_layer.cpp
│   │   │   ├── cudnn_conv_layer.cu
│   │   │   ├── cudnn_lcn_layer.cpp
│   │   │   ├── cudnn_lcn_layer.cu
│   │   │   ├── cudnn_lrn_layer.cpp
│   │   │   ├── cudnn_lrn_layer.cu
│   │   │   ├── cudnn_pooling_layer.cpp
│   │   │   ├── cudnn_pooling_layer.cu
│   │   │   ├── cudnn_relu_layer.cpp
│   │   │   ├── cudnn_relu_layer.cu
│   │   │   ├── cudnn_sigmoid_layer.cpp
│   │   │   ├── cudnn_sigmoid_layer.cu
│   │   │   ├── cudnn_softmax_layer.cpp
│   │   │   ├── cudnn_softmax_layer.cu
│   │   │   ├── cudnn_tanh_layer.cpp
│   │   │   ├── cudnn_tanh_layer.cu
│   │   │   ├── data_layer.cpp
│   │   │   ├── deconv_layer.cpp
│   │   │   ├── deconv_layer.cu
│   │   │   ├── depthwise_conv_layer.cpp
│   │   │   ├── depthwise_conv_layer.cu
│   │   │   ├── detection_evaluate_layer.cpp
│   │   │   ├── dropout_layer.cpp
│   │   │   ├── dropout_layer.cu
│   │   │   ├── dummy_data_layer.cpp
│   │   │   ├── eltwise_layer.cpp
│   │   │   ├── eltwise_layer.cu
│   │   │   ├── elu_layer.cpp
│   │   │   ├── elu_layer.cu
│   │   │   ├── embed_layer.cpp
│   │   │   ├── embed_layer.cu
│   │   │   ├── euclidean_loss_layer.cpp
│   │   │   ├── euclidean_loss_layer.cu
│   │   │   ├── exp_layer.cpp
│   │   │   ├── exp_layer.cu
│   │   │   ├── filter_layer.cpp
│   │   │   ├── filter_layer.cu
│   │   │   ├── flatten_layer.cpp
│   │   │   ├── hdf5_data_layer.cpp
│   │   │   ├── hdf5_data_layer.cu
│   │   │   ├── hdf5_output_layer.cpp
│   │   │   ├── hdf5_output_layer.cu
│   │   │   ├── hinge_loss_layer.cpp
│   │   │   ├── im2col_layer.cpp
│   │   │   ├── im2col_layer.cu
│   │   │   ├── image_data_layer.cpp
│   │   │   ├── infogain_loss_layer.cpp
│   │   │   ├── inner_product_layer.cpp
│   │   │   ├── inner_product_layer.cu
│   │   │   ├── input_layer.cpp
│   │   │   ├── loss_layer.cpp
│   │   │   ├── lrn_layer.cpp
│   │   │   ├── lrn_layer.cu
│   │   │   ├── lstm_layer.cpp
│   │   │   ├── lstm_unit_layer.cpp
│   │   │   ├── lstm_unit_layer.cu
│   │   │   ├── memory_data_layer.cpp
│   │   │   ├── multinomial_logistic_loss_layer.cpp
│   │   │   ├── mvn_layer.cpp
│   │   │   ├── mvn_layer.cu
│   │   │   ├── neuron_layer.cpp
│   │   │   ├── normalize_layer.cpp
│   │   │   ├── normalize_layer.cu
│   │   │   ├── parameter_layer.cpp
│   │   │   ├── pooling_layer.cpp
│   │   │   ├── pooling_layer.cu
│   │   │   ├── power_layer.cpp
│   │   │   ├── power_layer.cu
│   │   │   ├── prelu_layer.cpp
│   │   │   ├── prelu_layer.cu
│   │   │   ├── recurrent_layer.cpp
│   │   │   ├── recurrent_layer.cu
│   │   │   ├── reduction_layer.cpp
│   │   │   ├── reduction_layer.cu
│   │   │   ├── region_loss_layer.cpp
│   │   │   ├── relu6_layer.cpp
│   │   │   ├── relu6_layer.cu
│   │   │   ├── relu_layer.cpp
│   │   │   ├── relu_layer.cu
│   │   │   ├── reorg_layer.cpp
│   │   │   ├── reorg_layer.cu
│   │   │   ├── reshape_layer.cpp
│   │   │   ├── rnn_layer.cpp
│   │   │   ├── scale_layer.cpp
│   │   │   ├── scale_layer.cu
│   │   │   ├── sigmoid_cross_entropy_loss_layer.cpp
│   │   │   ├── sigmoid_cross_entropy_loss_layer.cu
│   │   │   ├── sigmoid_layer.cpp
│   │   │   ├── sigmoid_layer.cu
│   │   │   ├── silence_layer.cpp
│   │   │   ├── silence_layer.cu
│   │   │   ├── slice_layer.cpp
│   │   │   ├── slice_layer.cu
│   │   │   ├── smooth_L1_loss_layer.cpp
│   │   │   ├── smooth_L1_loss_layer.cu
│   │   │   ├── softmax_layer.cpp
│   │   │   ├── softmax_layer.cu
│   │   │   ├── softmax_loss_layer.cpp
│   │   │   ├── softmax_loss_layer.cu
│   │   │   ├── split_layer.cpp
│   │   │   ├── split_layer.cu
│   │   │   ├── spp_layer.cpp
│   │   │   ├── tanh_layer.cpp
│   │   │   ├── tanh_layer.cu
│   │   │   ├── threshold_layer.cpp
│   │   │   ├── threshold_layer.cu
│   │   │   ├── tile_layer.cpp
│   │   │   ├── tile_layer.cu
│   │   │   ├── window_data_layer.cpp
│   │   │   ├── yolo_detection_output_layer.cpp
│   │   │   ├── yolov3_detection_output_layer.cpp
│   │   │   ├── yolov3_layer.cpp
│   │   │   └── yolov3_layer.cu
│   │   ├── net.cpp
│   │   ├── parallel.cpp
│   │   ├── proto/
│   │   │   └── caffe.proto
│   │   ├── solver.cpp
│   │   ├── solver_factory.cpp
│   │   ├── solvers/
│   │   │   ├── adadelta_solver.cpp
│   │   │   ├── adadelta_solver.cu
│   │   │   ├── adagrad_solver.cpp
│   │   │   ├── adagrad_solver.cu
│   │   │   ├── adam_solver.cpp
│   │   │   ├── adam_solver.cu
│   │   │   ├── nesterov_solver.cpp
│   │   │   ├── nesterov_solver.cu
│   │   │   ├── rmsprop_solver.cpp
│   │   │   ├── rmsprop_solver.cu
│   │   │   ├── sgd_solver.cpp
│   │   │   └── sgd_solver.cu
│   │   ├── syncedmem.cpp
│   │   ├── test/
│   │   │   ├── CMakeLists.txt
│   │   │   ├── test_accuracy_layer.cpp
│   │   │   ├── test_annotated_data_layer.cpp
│   │   │   ├── test_argmax_layer.cpp
│   │   │   ├── test_batch_norm_layer.cpp
│   │   │   ├── test_batch_reindex_layer.cpp
│   │   │   ├── test_bbox_util.cpp
│   │   │   ├── test_benchmark.cpp
│   │   │   ├── test_bias_layer.cpp
│   │   │   ├── test_blob.cpp
│   │   │   ├── test_caffe_main.cpp
│   │   │   ├── test_common.cpp
│   │   │   ├── test_concat_layer.cpp
│   │   │   ├── test_contrastive_loss_layer.cpp
│   │   │   ├── test_convolution_layer.cpp
│   │   │   ├── test_crop_layer.cpp
│   │   │   ├── test_data/
│   │   │   │   ├── generate_sample_data.py
│   │   │   │   ├── sample_data.h5
│   │   │   │   ├── sample_data_2_gzip.h5
│   │   │   │   ├── sample_data_list.txt
│   │   │   │   ├── solver_data.h5
│   │   │   │   └── solver_data_list.txt
│   │   │   ├── test_data_layer.cpp
│   │   │   ├── test_data_transformer.cpp
│   │   │   ├── test_db.cpp
│   │   │   ├── test_deconvolution_layer.cpp
│   │   │   ├── test_dummy_data_layer.cpp
│   │   │   ├── test_eltwise_layer.cpp
│   │   │   ├── test_embed_layer.cpp
│   │   │   ├── test_euclidean_loss_layer.cpp
│   │   │   ├── test_filler.cpp
│   │   │   ├── test_filter_layer.cpp
│   │   │   ├── test_flatten_layer.cpp
│   │   │   ├── test_gradient_based_solver.cpp
│   │   │   ├── test_hdf5_output_layer.cpp
│   │   │   ├── test_hdf5data_layer.cpp
│   │   │   ├── test_hinge_loss_layer.cpp
│   │   │   ├── test_im2col_kernel.cu
│   │   │   ├── test_im2col_layer.cpp
│   │   │   ├── test_im_transforms.cpp
│   │   │   ├── test_image_data_layer.cpp
│   │   │   ├── test_infogain_loss_layer.cpp
│   │   │   ├── test_inner_product_layer.cpp
│   │   │   ├── test_internal_thread.cpp
│   │   │   ├── test_io.cpp
│   │   │   ├── test_layer_factory.cpp
│   │   │   ├── test_lrn_layer.cpp
│   │   │   ├── test_lstm_layer.cpp
│   │   │   ├── test_math_functions.cpp
│   │   │   ├── test_maxpool_dropout_layers.cpp
│   │   │   ├── test_memory_data_layer.cpp
│   │   │   ├── test_multinomial_logistic_loss_layer.cpp
│   │   │   ├── test_mvn_layer.cpp
│   │   │   ├── test_net.cpp
│   │   │   ├── test_neuron_layer.cpp
│   │   │   ├── test_platform.cpp
│   │   │   ├── test_pooling_layer.cpp
│   │   │   ├── test_power_layer.cpp
│   │   │   ├── test_protobuf.cpp
│   │   │   ├── test_random_number_generator.cpp
│   │   │   ├── test_reduction_layer.cpp
│   │   │   ├── test_reshape_layer.cpp
│   │   │   ├── test_rnn_layer.cpp
│   │   │   ├── test_scale_layer.cpp
│   │   │   ├── test_sigmoid_cross_entropy_loss_layer.cpp
│   │   │   ├── test_slice_layer.cpp
│   │   │   ├── test_softmax_layer.cpp
│   │   │   ├── test_softmax_with_loss_layer.cpp
│   │   │   ├── test_solver.cpp
│   │   │   ├── test_solver_factory.cpp
│   │   │   ├── test_split_layer.cpp
│   │   │   ├── test_spp_layer.cpp
│   │   │   ├── test_stochastic_pooling.cpp
│   │   │   ├── test_syncedmem.cpp
│   │   │   ├── test_tanh_layer.cpp
│   │   │   ├── test_threshold_layer.cpp
│   │   │   ├── test_tile_layer.cpp
│   │   │   ├── test_upgrade_proto.cpp
│   │   │   └── test_util_blas.cpp
│   │   └── util/
│   │       ├── bbox_util.cpp
│   │       ├── bbox_util.cu
│   │       ├── benchmark.cpp
│   │       ├── blocking_queue.cpp
│   │       ├── cudnn.cpp
│   │       ├── db.cpp
│   │       ├── db_leveldb.cpp
│   │       ├── db_lmdb.cpp
│   │       ├── hdf5.cpp
│   │       ├── im2col.cpp
│   │       ├── im2col.cu
│   │       ├── im_transforms.cpp
│   │       ├── insert_splits.cpp
│   │       ├── io.cpp
│   │       ├── math_functions.cpp
│   │       ├── math_functions.cu
│   │       ├── sampler.cpp
│   │       ├── signal_handler.cpp
│   │       └── upgrade_proto.cpp
│   └── gtest/
│       ├── CMakeLists.txt
│       ├── gtest-all.cpp
│       ├── gtest.h
│       └── gtest_main.cc
└── tools/
    ├── CMakeLists.txt
    ├── caffe.cpp
    ├── compute_image_mean.cpp
    ├── convert_annoset.cpp
    ├── convert_imageset.cpp
    ├── create_label_map.cpp
    ├── device_query.cpp
    ├── extra/
    │   ├── extract_seconds.py
    │   ├── launch_resize_and_crop_images.sh
    │   ├── parse_log.py
    │   ├── parse_log.sh
    │   ├── plot_log.gnuplot.example
    │   ├── plot_training_log.py.example
    │   ├── resize_and_crop_images.py
    │   └── summarize.py
    ├── extract_features.cpp
    ├── finetune_net.cpp
    ├── get_image_size.cpp
    ├── net_speed_benchmark.cpp
    ├── test_net.cpp
    ├── train_net.cpp
    ├── upgrade_net_proto_binary.cpp
    ├── upgrade_net_proto_text.cpp
    └── upgrade_solver_proto_text.cpp

SYMBOL INDEX (3332 symbols across 376 files)

FILE: examples/cifar10/convert_cifar_data.cpp
  function read_image (line 31) | void read_image(std::ifstream* file, int* label, char* buffer) {
  function convert_dataset (line 39) | void convert_dataset(const string& input_folder, const string& output_fo...
  function main (line 93) | int main(int argc, char** argv) {

FILE: examples/cpp_classification/classification.cpp
  class Classifier (line 21) | class Classifier {
  function PairCompare (line 86) | static bool PairCompare(const std::pair<float, int>& lhs,
  function Argmax (line 92) | static std::vector<int> Argmax(const std::vector<float>& v, int N) {
  function main (line 229) | int main(int argc, char** argv) {
  function main (line 262) | int main(int argc, char** argv) {

FILE: examples/finetune_flickr_style/assemble_data.py
  function download_image (line 23) | def download_image(args_tuple):

FILE: examples/mnist/convert_mnist_data.cpp
  function swap_endian (line 43) | uint32_t swap_endian(uint32_t val) {
  function convert_dataset (line 48) | void convert_dataset(const char* image_filename, const char* label_filen...
  function main (line 118) | int main(int argc, char** argv) {
  function main (line 148) | int main(int argc, char** argv) {

FILE: examples/pycaffe/caffenet.py
  function conv_relu (line 7) | def conv_relu(bottom, ks, nout, stride=1, pad=0, group=1):
  function fc_relu (line 12) | def fc_relu(bottom, nout):
  function max_pool (line 16) | def max_pool(bottom, ks, stride=1):
  function caffenet (line 19) | def caffenet(lmdb, batch_size=256, include_acc=False):
  function make_net (line 47) | def make_net():

FILE: examples/pycaffe/layers/pascal_multilabel_datalayers.py
  class PascalMultilabelDataLayerSync (line 20) | class PascalMultilabelDataLayerSync(caffe.Layer):
    method setup (line 27) | def setup(self, bottom, top):
    method forward (line 55) | def forward(self, bottom, top):
    method reshape (line 67) | def reshape(self, bottom, top):
    method backward (line 74) | def backward(self, top, propagate_down, bottom):
  class BatchLoader (line 81) | class BatchLoader(object):
    method __init__ (line 90) | def __init__(self, params, result):
    method load_next_image (line 106) | def load_next_image(self):
  function load_pascal_annotation (line 140) | def load_pascal_annotation(index, pascal_root):
  function check_params (line 196) | def check_params(params):
  function print_info (line 208) | def print_info(name, params):

FILE: examples/pycaffe/layers/pyloss.py
  class EuclideanLossLayer (line 5) | class EuclideanLossLayer(caffe.Layer):
    method setup (line 11) | def setup(self, bottom, top):
    method reshape (line 16) | def reshape(self, bottom, top):
    method forward (line 25) | def forward(self, bottom, top):
    method backward (line 29) | def backward(self, top, propagate_down, bottom):

FILE: examples/pycaffe/tools.py
  class SimpleTransformer (line 4) | class SimpleTransformer:
    method __init__ (line 11) | def __init__(self, mean=[128, 128, 128]):
    method set_mean (line 15) | def set_mean(self, mean):
    method set_scale (line 21) | def set_scale(self, scale):
    method preprocess (line 27) | def preprocess(self, im):
    method deprocess (line 41) | def deprocess(self, im):
  class CaffeSolver (line 53) | class CaffeSolver:
    method __init__ (line 62) | def __init__(self, testnet_prototxt_path="testnet.prototxt",
    method add_from_file (line 101) | def add_from_file(self, filepath):
    method write (line 113) | def write(self, filepath):

FILE: examples/siamese/convert_mnist_siamese_data.cpp
  function swap_endian (line 22) | uint32_t swap_endian(uint32_t val) {
  function read_image (line 27) | void read_image(std::ifstream* image_file, std::ifstream* label_file,
  function convert_dataset (line 36) | void convert_dataset(const char* image_filename, const char* label_filen...
  function main (line 109) | int main(int argc, char** argv) {
  function main (line 126) | int main(int argc, char** argv) {

FILE: examples/ssd/plot_detections.py
  function get_labelname (line 20) | def get_labelname(labelmap, labels):
  function showResults (line 35) | def showResults(img_file, results, labelmap=None, threshold=None, displa...

FILE: examples/ssd/score_ssd_coco.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/score_ssd_pascal.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_coco.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_detect.cpp
  class Detector (line 74) | class Detector {
  function sec (line 131) | float sec(clock_t clocks)
  function main (line 342) | int main(int argc, char** argv) {
  function main (line 629) | int main(int argc, char** argv) {

FILE: examples/ssd/ssd_ilsvrc.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_pascal.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_pascal_orig.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_pascal_resnet.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True):

FILE: examples/ssd/ssd_pascal_speed.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_pascal_video.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_pascal_webcam.py
  function AddExtraLayers (line 14) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/ssd_pascal_zf.py
  function AddExtraLayers (line 19) | def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):

FILE: examples/ssd/test_ssd.py
  function vis_detections (line 56) | def vis_detections(image,result) :
  function det (line 78) | def det(image, pic):

FILE: examples/web_demo/app.py
  function index (line 29) | def index():
  function classify_url (line 34) | def classify_url():
  function classify_upload (line 57) | def classify_upload():
  function embed_image_html (line 82) | def embed_image_html(image):
  function allowed_file (line 92) | def allowed_file(filename):
  class ImagenetClassifier (line 99) | class ImagenetClassifier(object):
    method __init__ (line 119) | def __init__(self, model_def_file, pretrained_model_file, mean_file,
    method classify_image (line 148) | def classify_image(self, image):
  function start_tornado (line 184) | def start_tornado(app, port=5000):
  function start_from_terminal (line 192) | def start_from_terminal(app):

FILE: examples/web_demo/exifutil.py
  function open_oriented_im (line 19) | def open_oriented_im(im_path):
  function apply_orientation (line 35) | def apply_orientation(im, orientation):

FILE: include/caffe/blob.hpp
  type caffe (line 14) | namespace caffe {
    class Blob (line 24) | class Blob {
      method Blob (line 26) | Blob()
      method string (line 54) | inline string shape_string() const {
      method shape (line 71) | inline int shape(int index) const {
      method num_axes (line 74) | inline int num_axes() const { return shape_.size(); }
      method count (line 75) | inline int count() const { return count_; }
      method count (line 85) | inline int count(int start_axis, int end_axis) const {
      method count (line 103) | inline int count(int start_axis) const {
      method CanonicalAxisIndex (line 118) | inline int CanonicalAxisIndex(int axis_index) const {
      method num (line 132) | inline int num() const { return LegacyShape(0); }
      method channels (line 134) | inline int channels() const { return LegacyShape(1); }
      method height (line 136) | inline int height() const { return LegacyShape(2); }
      method width (line 138) | inline int width() const { return LegacyShape(3); }
      method LegacyShape (line 139) | inline int LegacyShape(int index) const {
      method offset (line 153) | inline int offset(const int n, const int c = 0, const int h = 0,
      method offset (line 166) | inline int offset(const vector<int>& indices) const {
      method Dtype (line 191) | inline Dtype data_at(const int n, const int c, const int h,
      method Dtype (line 196) | inline Dtype diff_at(const int n, const int c, const int h,
      method Dtype (line 201) | inline Dtype data_at(const vector<int>& index) const {
      method Dtype (line 205) | inline Dtype diff_at(const vector<int>& index) const {

FILE: include/caffe/common.hpp
  type cv (line 76) | namespace cv { class Mat; }
    class Mat (line 76) | class Mat
  type caffe (line 78) | namespace caffe {
    class Caffe (line 105) | class Caffe {
      type Brew (line 114) | enum Brew { CPU, GPU }
      class RNG (line 118) | class RNG {
        class Generator (line 126) | class Generator
      method RNG (line 131) | inline static RNG& rng_stream() {
        class Generator (line 126) | class Generator
      method cublasHandle_t (line 138) | inline static cublasHandle_t cublas_handle() { return Get().cublas_h...
      method curandGenerator_t (line 139) | inline static curandGenerator_t curand_generator() {
      method Brew (line 145) | inline static Brew mode() { return Get().mode_; }
      method set_mode (line 151) | inline static void set_mode(Brew mode) { Get().mode_ = mode; }
      method solver_count (line 165) | inline static int solver_count() { return Get().solver_count_; }
      method set_solver_count (line 166) | inline static void set_solver_count(int val) { Get().solver_count_ =...
      method solver_rank (line 167) | inline static int solver_rank() { return Get().solver_rank_; }
      method set_solver_rank (line 168) | inline static void set_solver_rank(int val) { Get().solver_rank_ = v...
      method multiprocess (line 169) | inline static bool multiprocess() { return Get().multiprocess_; }
      method set_multiprocess (line 170) | inline static void set_multiprocess(bool val) { Get().multiprocess_ ...
      method root_solver (line 171) | inline static bool root_solver() { return Get().solver_rank_ == 0; }

FILE: include/caffe/data_reader.hpp
  type caffe (line 13) | namespace caffe {
    class DataReader (line 24) | class DataReader {
      class QueuePair (line 38) | class QueuePair {
      class Body (line 50) | class Body : public InternalThread {
      method string (line 69) | static inline string source_key(const LayerParameter& param) {

FILE: include/caffe/data_transformer.hpp
  type caffe (line 14) | namespace caffe {
    class DataTransformer (line 21) | class DataTransformer {

FILE: include/caffe/filler.hpp
  type caffe (line 15) | namespace caffe {
    class Filler (line 19) | class Filler {
      method Filler (line 21) | explicit Filler(const FillerParameter& param) : filler_param_(param) {}
    class ConstantFiller (line 31) | class ConstantFiller : public Filler<Dtype> {
      method ConstantFiller (line 33) | explicit ConstantFiller(const FillerParameter& param)
      method Fill (line 35) | virtual void Fill(Blob<Dtype>* blob) {
    class UniformFiller (line 50) | class UniformFiller : public Filler<Dtype> {
      method UniformFiller (line 52) | explicit UniformFiller(const FillerParameter& param)
      method Fill (line 54) | virtual void Fill(Blob<Dtype>* blob) {
    class GaussianFiller (line 65) | class GaussianFiller : public Filler<Dtype> {
      method GaussianFiller (line 67) | explicit GaussianFiller(const FillerParameter& param)
      method Fill (line 69) | virtual void Fill(Blob<Dtype>* blob) {
    class PositiveUnitballFiller (line 101) | class PositiveUnitballFiller : public Filler<Dtype> {
      method PositiveUnitballFiller (line 103) | explicit PositiveUnitballFiller(const FillerParameter& param)
      method Fill (line 105) | virtual void Fill(Blob<Dtype>* blob) {
    class XavierFiller (line 144) | class XavierFiller : public Filler<Dtype> {
      method XavierFiller (line 146) | explicit XavierFiller(const FillerParameter& param)
      method Fill (line 148) | virtual void Fill(Blob<Dtype>* blob) {
    class MSRAFiller (line 189) | class MSRAFiller : public Filler<Dtype> {
      method MSRAFiller (line 191) | explicit MSRAFiller(const FillerParameter& param)
      method Fill (line 193) | virtual void Fill(Blob<Dtype>* blob) {
    class BilinearFiller (line 250) | class BilinearFiller : public Filler<Dtype> {
      method BilinearFiller (line 252) | explicit BilinearFiller(const FillerParameter& param)
      method Fill (line 254) | virtual void Fill(Blob<Dtype>* blob) {

FILE: include/caffe/internal_thread.hpp
  type boost (line 10) | namespace boost { class thread; }
    class thread (line 10) | class thread
  type caffe (line 12) | namespace caffe {
    class InternalThread (line 19) | class InternalThread {
      method InternalThread (line 21) | InternalThread() : thread_() {}
      method InternalThreadEntry (line 39) | virtual void InternalThreadEntry() {}

FILE: include/caffe/layer.hpp
  type boost (line 18) | namespace boost { class mutex; }
    class mutex (line 18) | class mutex
  type caffe (line 20) | namespace caffe {
    class Layer (line 33) | class Layer {
      method Layer (line 40) | explicit Layer(const LayerParameter& param)
      method SetUp (line 67) | void SetUp(const vector<Blob<Dtype>*>& bottom,
      method LayerSetUp (line 91) | virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      method LayerParameter (line 164) | const LayerParameter& layer_param() const { return layer_param_; }
      method Dtype (line 174) | inline Dtype loss(const int top_index) const {
      method set_loss (line 181) | inline void set_loss(const int top_index, const Dtype value) {
      method ExactNumBottomBlobs (line 200) | virtual inline int ExactNumBottomBlobs() const { return -1; }
      method MinBottomBlobs (line 208) | virtual inline int MinBottomBlobs() const { return -1; }
      method MaxBottomBlobs (line 216) | virtual inline int MaxBottomBlobs() const { return -1; }
      method ExactNumTopBlobs (line 224) | virtual inline int ExactNumTopBlobs() const { return -1; }
      method MinTopBlobs (line 232) | virtual inline int MinTopBlobs() const { return -1; }
      method MaxTopBlobs (line 240) | virtual inline int MaxTopBlobs() const { return -1; }
      method EqualNumBottomTopBlobs (line 248) | virtual inline bool EqualNumBottomTopBlobs() const { return false; }
      method AutoTopBlobs (line 258) | virtual inline bool AutoTopBlobs() const { return false; }
      method AllowForceBackward (line 268) | virtual inline bool AllowForceBackward(const int bottom_index) const {
      method param_propagate_down (line 279) | inline bool param_propagate_down(const int param_id) {
      method set_param_propagate_down (line 287) | inline void set_param_propagate_down(const int param_id, const bool ...
      method Forward_gpu (line 316) | virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_gpu (line 334) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      method CheckBlobCounts (line 346) | virtual void CheckBlobCounts(const vector<Blob<Dtype>*>& bottom,
      method SetLossWeights (line 389) | inline void SetLossWeights(const vector<Blob<Dtype>*>& top) {
    function Dtype (line 413) | inline Dtype Layer<Dtype>::Forward(const vector<Blob<Dtype>*>& bottom,

FILE: include/caffe/layer_factory.hpp
  type caffe (line 50) | namespace caffe {
    class Layer (line 53) | class Layer
    class LayerRegistry (line 56) | class LayerRegistry {
    class LayerRegisterer (line 80) | class LayerRegisterer {

FILE: include/caffe/layers/absval_layer.hpp
  type caffe (line 12) | namespace caffe {
    class AbsValLayer (line 25) | class AbsValLayer : public NeuronLayer<Dtype> {
      method AbsValLayer (line 27) | explicit AbsValLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 33) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 34) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/accuracy_layer.hpp
  type caffe (line 12) | namespace caffe {
    class AccuracyLayer (line 19) | class AccuracyLayer : public Layer<Dtype> {
      method AccuracyLayer (line 29) | explicit AccuracyLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 37) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method MinTopBlobs (line 41) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 42) | virtual inline int MaxTopBlobs() const { return 2; }
      method Backward_cpu (line 74) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/annotated_data_layer.hpp
  type caffe (line 16) | namespace caffe {
    class AnnotatedDataLayer (line 19) | class AnnotatedDataLayer : public BasePrefetchingDataLayer<Dtype> {
      method ShareInParallel (line 26) | virtual inline bool ShareInParallel() const { return false; }
      method ExactNumBottomBlobs (line 28) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 29) | virtual inline int MinTopBlobs() const { return 1; }

FILE: include/caffe/layers/argmax_layer.hpp
  type caffe (line 10) | namespace caffe {
    class ArgMaxLayer (line 24) | class ArgMaxLayer : public Layer<Dtype> {
      method ArgMaxLayer (line 38) | explicit ArgMaxLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 46) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 47) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Backward_cpu (line 65) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/base_conv_layer.hpp
  type caffe (line 11) | namespace caffe {
    class BaseConvolutionLayer (line 18) | class BaseConvolutionLayer : public Layer<Dtype> {
      method BaseConvolutionLayer (line 20) | explicit BaseConvolutionLayer(const LayerParameter& param)
      method MinBottomBlobs (line 27) | virtual inline int MinBottomBlobs() const { return 1; }
      method MinTopBlobs (line 28) | virtual inline int MinTopBlobs() const { return 1; }
      method EqualNumBottomTopBlobs (line 29) | virtual inline bool EqualNumBottomTopBlobs() const { return true; }
      method input_shape (line 56) | inline int input_shape(int i) {
      method conv_im2col_cpu (line 98) | inline void conv_im2col_cpu(const Dtype* data, Dtype* col_buff) {
      method conv_col2im_cpu (line 112) | inline void conv_col2im_cpu(const Dtype* col_buff, Dtype* data) {
      method conv_im2col_gpu (line 127) | inline void conv_im2col_gpu(const Dtype* data, Dtype* col_buff) {
      method conv_col2im_gpu (line 142) | inline void conv_col2im_gpu(const Dtype* col_buff, Dtype* data) {

FILE: include/caffe/layers/base_data_layer.hpp
  type caffe (line 13) | namespace caffe {
    class BaseDataLayer (line 21) | class BaseDataLayer : public Layer<Dtype> {
      method ShareInParallel (line 30) | virtual inline bool ShareInParallel() const { return true; }
      method DataLayerSetUp (line 31) | virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      method Reshape (line 34) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 37) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Backward_gpu (line 39) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
    class Batch (line 49) | class Batch {
    class BasePrefetchingDataLayer (line 55) | class BasePrefetchingDataLayer :

FILE: include/caffe/layers/batch_norm_layer.hpp
  type caffe (line 10) | namespace caffe {
    class BatchNormLayer (line 40) | class BatchNormLayer : public Layer<Dtype> {
      method BatchNormLayer (line 42) | explicit BatchNormLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 50) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 51) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/batch_reindex_layer.hpp
  type caffe (line 11) | namespace caffe {
    class BatchReindexLayer (line 21) | class BatchReindexLayer : public Layer<Dtype> {
      method BatchReindexLayer (line 23) | explicit BatchReindexLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 29) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 30) | virtual inline int ExactNumTopBlobs() const { return 1; }
      type pair_sort_first (line 71) | struct pair_sort_first {

FILE: include/caffe/layers/bias_layer.hpp
  type caffe (line 10) | namespace caffe {
    class BiasLayer (line 22) | class BiasLayer : public Layer<Dtype> {
      method BiasLayer (line 24) | explicit BiasLayer(const LayerParameter& param)
      method MinBottomBlobs (line 32) | virtual inline int MinBottomBlobs() const { return 1; }
      method MaxBottomBlobs (line 33) | virtual inline int MaxBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 34) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/bnll_layer.hpp
  type caffe (line 12) | namespace caffe {
    class BNLLLayer (line 32) | class BNLLLayer : public NeuronLayer<Dtype> {
      method BNLLLayer (line 34) | explicit BNLLLayer(const LayerParameter& param)

FILE: include/caffe/layers/concat_layer.hpp
  type caffe (line 10) | namespace caffe {
    class ConcatLayer (line 17) | class ConcatLayer : public Layer<Dtype> {
      method ConcatLayer (line 19) | explicit ConcatLayer(const LayerParameter& param)
      method MinBottomBlobs (line 27) | virtual inline int MinBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 28) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/contrastive_loss_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ContrastiveLossLayer (line 39) | class ContrastiveLossLayer : public LossLayer<Dtype> {
      method ContrastiveLossLayer (line 41) | explicit ContrastiveLossLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 46) | virtual inline int ExactNumBottomBlobs() const { return 3; }
      method AllowForceBackward (line 52) | virtual inline bool AllowForceBackward(const int bottom_index) const {

FILE: include/caffe/layers/conv_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ConvolutionLayer (line 31) | class ConvolutionLayer : public BaseConvolutionLayer<Dtype> {
      method ConvolutionLayer (line 64) | explicit ConvolutionLayer(const LayerParameter& param)
      method reverse_dimensions (line 78) | virtual inline bool reverse_dimensions() { return false; }

FILE: include/caffe/layers/crop_layer.hpp
  type caffe (line 11) | namespace caffe {
    class CropLayer (line 21) | class CropLayer : public Layer<Dtype> {
      method CropLayer (line 23) | explicit CropLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 31) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 32) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/cudnn_conv_layer.hpp
  type caffe (line 12) | namespace caffe {
    class CuDNNConvolutionLayer (line 30) | class CuDNNConvolutionLayer : public ConvolutionLayer<Dtype> {
      method CuDNNConvolutionLayer (line 32) | explicit CuDNNConvolutionLayer(const LayerParameter& param)

FILE: include/caffe/layers/cudnn_lcn_layer.hpp
  type caffe (line 13) | namespace caffe {
    class CuDNNLCNLayer (line 17) | class CuDNNLCNLayer : public LRNLayer<Dtype> {
      method CuDNNLCNLayer (line 19) | explicit CuDNNLCNLayer(const LayerParameter& param)

FILE: include/caffe/layers/cudnn_lrn_layer.hpp
  type caffe (line 12) | namespace caffe {
    class CuDNNLRNLayer (line 16) | class CuDNNLRNLayer : public LRNLayer<Dtype> {
      method CuDNNLRNLayer (line 18) | explicit CuDNNLRNLayer(const LayerParameter& param)

FILE: include/caffe/layers/cudnn_pooling_layer.hpp
  type caffe (line 12) | namespace caffe {
    class CuDNNPoolingLayer (line 20) | class CuDNNPoolingLayer : public PoolingLayer<Dtype> {
      method CuDNNPoolingLayer (line 22) | explicit CuDNNPoolingLayer(const LayerParameter& param)
      method MinTopBlobs (line 30) | virtual inline int MinTopBlobs() const { return -1; }
      method ExactNumTopBlobs (line 31) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/cudnn_relu_layer.hpp
  type caffe (line 13) | namespace caffe {
    class CuDNNReLULayer (line 20) | class CuDNNReLULayer : public ReLULayer<Dtype> {
      method CuDNNReLULayer (line 22) | explicit CuDNNReLULayer(const LayerParameter& param)

FILE: include/caffe/layers/cudnn_sigmoid_layer.hpp
  type caffe (line 13) | namespace caffe {
    class CuDNNSigmoidLayer (line 20) | class CuDNNSigmoidLayer : public SigmoidLayer<Dtype> {
      method CuDNNSigmoidLayer (line 22) | explicit CuDNNSigmoidLayer(const LayerParameter& param)

FILE: include/caffe/layers/cudnn_softmax_layer.hpp
  type caffe (line 12) | namespace caffe {
    class CuDNNSoftmaxLayer (line 20) | class CuDNNSoftmaxLayer : public SoftmaxLayer<Dtype> {
      method CuDNNSoftmaxLayer (line 22) | explicit CuDNNSoftmaxLayer(const LayerParameter& param)

FILE: include/caffe/layers/cudnn_tanh_layer.hpp
  type caffe (line 13) | namespace caffe {
    class CuDNNTanHLayer (line 20) | class CuDNNTanHLayer : public TanHLayer<Dtype> {
      method CuDNNTanHLayer (line 22) | explicit CuDNNTanHLayer(const LayerParameter& param)

FILE: include/caffe/layers/data_layer.hpp
  type caffe (line 15) | namespace caffe {
    class DataLayer (line 18) | class DataLayer : public BasePrefetchingDataLayer<Dtype> {
      method ExactNumBottomBlobs (line 25) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 26) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 27) | virtual inline int MaxTopBlobs() const { return 2; }

FILE: include/caffe/layers/deconv_layer.hpp
  type caffe (line 12) | namespace caffe {
    class DeconvolutionLayer (line 29) | class DeconvolutionLayer : public BaseConvolutionLayer<Dtype> {
      method DeconvolutionLayer (line 31) | explicit DeconvolutionLayer(const LayerParameter& param)
      method reverse_dimensions (line 45) | virtual inline bool reverse_dimensions() { return true; }

FILE: include/caffe/layers/depthwise_conv_layer.hpp
  type caffe (line 21) | namespace caffe {
    class DepthwiseConvolutionLayer (line 40) | class DepthwiseConvolutionLayer : public BaseConvolutionLayer<Dtype> {
      method DepthwiseConvolutionLayer (line 73) | explicit DepthwiseConvolutionLayer(const LayerParameter& param)
      method reverse_dimensions (line 87) | virtual inline bool reverse_dimensions() { return false; }

FILE: include/caffe/layers/detection_evaluate_layer.hpp
  type caffe (line 11) | namespace caffe {
    class DetectionEvaluateLayer (line 22) | class DetectionEvaluateLayer : public Layer<Dtype> {
      method DetectionEvaluateLayer (line 24) | explicit DetectionEvaluateLayer(const LayerParameter& param)
      method ExactBottomBlobs (line 32) | virtual inline int ExactBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 33) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Backward_cpu (line 52) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/dropout_layer.hpp
  type caffe (line 12) | namespace caffe {
    class DropoutLayer (line 26) | class DropoutLayer : public NeuronLayer<Dtype> {
      method DropoutLayer (line 34) | explicit DropoutLayer(const LayerParameter& param)

FILE: include/caffe/layers/dummy_data_layer.hpp
  type caffe (line 11) | namespace caffe {
    class DummyDataLayer (line 19) | class DummyDataLayer : public Layer<Dtype> {
      method DummyDataLayer (line 21) | explicit DummyDataLayer(const LayerParameter& param)
      method Reshape (line 26) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 30) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 31) | virtual inline int MinTopBlobs() const { return 1; }
      method Backward_cpu (line 36) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Backward_gpu (line 38) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/eltwise_layer.hpp
  type caffe (line 10) | namespace caffe {
    class EltwiseLayer (line 19) | class EltwiseLayer : public Layer<Dtype> {
      method EltwiseLayer (line 21) | explicit EltwiseLayer(const LayerParameter& param)
      method MinBottomBlobs (line 29) | virtual inline int MinBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 30) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/elu_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ELULayer (line 24) | class ELULayer : public NeuronLayer<Dtype> {
      method ELULayer (line 32) | explicit ELULayer(const LayerParameter& param)

FILE: include/caffe/layers/embed_layer.hpp
  type caffe (line 10) | namespace caffe {
    class EmbedLayer (line 20) | class EmbedLayer : public Layer<Dtype> {
      method EmbedLayer (line 22) | explicit EmbedLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 30) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 31) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/euclidean_loss_layer.hpp
  type caffe (line 12) | namespace caffe {
    class EuclideanLossLayer (line 41) | class EuclideanLossLayer : public LossLayer<Dtype> {
      method EuclideanLossLayer (line 43) | explicit EuclideanLossLayer(const LayerParameter& param)
      method AllowForceBackward (line 53) | virtual inline bool AllowForceBackward(const int bottom_index) const {

FILE: include/caffe/layers/exp_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ExpLayer (line 20) | class ExpLayer : public NeuronLayer<Dtype> {
      method ExpLayer (line 30) | explicit ExpLayer(const LayerParameter& param)

FILE: include/caffe/layers/filter_layer.hpp
  type caffe (line 10) | namespace caffe {
    class FilterLayer (line 19) | class FilterLayer : public Layer<Dtype> {
      method FilterLayer (line 21) | explicit FilterLayer(const LayerParameter& param)
      method MinBottomBlobs (line 29) | virtual inline int MinBottomBlobs() const { return 2; }
      method MinTopBlobs (line 30) | virtual inline int MinTopBlobs() const { return 1; }

FILE: include/caffe/layers/flatten_layer.hpp
  type caffe (line 10) | namespace caffe {
    class FlattenLayer (line 23) | class FlattenLayer : public Layer<Dtype> {
      method FlattenLayer (line 25) | explicit FlattenLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 31) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 32) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/hdf5_data_layer.hpp
  type caffe (line 15) | namespace caffe {
    class HDF5DataLayer (line 23) | class HDF5DataLayer : public Layer<Dtype> {
      method HDF5DataLayer (line 25) | explicit HDF5DataLayer(const LayerParameter& param)
      method Reshape (line 31) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 35) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 36) | virtual inline int MinTopBlobs() const { return 1; }
      method Backward_cpu (line 46) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Backward_gpu (line 48) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/hdf5_output_layer.hpp
  type caffe (line 13) | namespace caffe {
    class HDF5OutputLayer (line 24) | class HDF5OutputLayer : public Layer<Dtype> {
      method HDF5OutputLayer (line 26) | explicit HDF5OutputLayer(const LayerParameter& param)
      method Reshape (line 32) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 37) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 38) | virtual inline int ExactNumTopBlobs() const { return 0; }
      method file_name (line 40) | inline std::string file_name() const { return file_name_; }

FILE: include/caffe/layers/hinge_loss_layer.hpp
  type caffe (line 12) | namespace caffe {
    class HingeLossLayer (line 58) | class HingeLossLayer : public LossLayer<Dtype> {
      method HingeLossLayer (line 60) | explicit HingeLossLayer(const LayerParameter& param)

FILE: include/caffe/layers/im2col_layer.hpp
  type caffe (line 10) | namespace caffe {
    class Im2colLayer (line 20) | class Im2colLayer : public Layer<Dtype> {
      method Im2colLayer (line 22) | explicit Im2colLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 30) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 31) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/image_data_layer.hpp
  type caffe (line 15) | namespace caffe {
    class ImageDataLayer (line 23) | class ImageDataLayer : public BasePrefetchingDataLayer<Dtype> {
      method ImageDataLayer (line 25) | explicit ImageDataLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 32) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 33) | virtual inline int ExactNumTopBlobs() const { return 2; }

FILE: include/caffe/layers/infogain_loss_layer.hpp
  type caffe (line 13) | namespace caffe {
    class InfogainLossLayer (line 48) | class InfogainLossLayer : public LossLayer<Dtype> {
      method InfogainLossLayer (line 50) | explicit InfogainLossLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 60) | virtual inline int ExactNumBottomBlobs() const { return -1; }
      method MinBottomBlobs (line 61) | virtual inline int MinBottomBlobs() const { return 2; }
      method MaxBottomBlobs (line 62) | virtual inline int MaxBottomBlobs() const { return 3; }
      method ExactNumTopBlobs (line 66) | virtual inline int ExactNumTopBlobs() const { return -1; }
      method MinTopBlobs (line 67) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 68) | virtual inline int MaxTopBlobs() const { return 2; }

FILE: include/caffe/layers/inner_product_layer.hpp
  type caffe (line 10) | namespace caffe {
    class InnerProductLayer (line 19) | class InnerProductLayer : public Layer<Dtype> {
      method InnerProductLayer (line 21) | explicit InnerProductLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 29) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 30) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/input_layer.hpp
  type caffe (line 10) | namespace caffe {
    class InputLayer (line 19) | class InputLayer : public Layer<Dtype> {
      method InputLayer (line 21) | explicit InputLayer(const LayerParameter& param)
      method Reshape (line 26) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 30) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 31) | virtual inline int MinTopBlobs() const { return 1; }
      method Forward_cpu (line 34) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 36) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/loss_layer.hpp
  type caffe (line 10) | namespace caffe {
    class LossLayer (line 23) | class LossLayer : public Layer<Dtype> {
      method LossLayer (line 25) | explicit LossLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 32) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method AutoTopBlobs (line 40) | virtual inline bool AutoTopBlobs() const { return true; }
      method ExactNumTopBlobs (line 41) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method AllowForceBackward (line 46) | virtual inline bool AllowForceBackward(const int bottom_index) const {

FILE: include/caffe/layers/lrn_layer.hpp
  type caffe (line 15) | namespace caffe {
    class LRNLayer (line 23) | class LRNLayer : public Layer<Dtype> {
      method LRNLayer (line 25) | explicit LRNLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 33) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 34) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/lstm_layer.hpp
  type caffe (line 15) | namespace caffe {
    class RecurrentLayer (line 17) | class RecurrentLayer
    class LSTMLayer (line 48) | class LSTMLayer : public RecurrentLayer<Dtype> {
      method LSTMLayer (line 50) | explicit LSTMLayer(const LayerParameter& param)
    class LSTMUnitLayer (line 69) | class LSTMUnitLayer : public Layer<Dtype> {
      method LSTMUnitLayer (line 71) | explicit LSTMUnitLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 77) | virtual inline int ExactNumBottomBlobs() const { return 3; }
      method ExactNumTopBlobs (line 78) | virtual inline int ExactNumTopBlobs() const { return 2; }
      method AllowForceBackward (line 80) | virtual inline bool AllowForceBackward(const int bottom_index) const {

FILE: include/caffe/layers/memory_data_layer.hpp
  type caffe (line 12) | namespace caffe {
    class MemoryDataLayer (line 20) | class MemoryDataLayer : public BaseDataLayer<Dtype> {
      method MemoryDataLayer (line 22) | explicit MemoryDataLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 28) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 29) | virtual inline int ExactNumTopBlobs() const { return 2; }
      method batch_size (line 42) | int batch_size() { return batch_size_; }
      method channels (line 43) | int channels() { return channels_; }
      method height (line 44) | int height() { return height_; }
      method width (line 45) | int width() { return width_; }

FILE: include/caffe/layers/multinomial_logistic_loss_layer.hpp
  type caffe (line 12) | namespace caffe {
    class MultinomialLogisticLossLayer (line 44) | class MultinomialLogisticLossLayer : public LossLayer<Dtype> {
      method MultinomialLogisticLossLayer (line 46) | explicit MultinomialLogisticLossLayer(const LayerParameter& param)

FILE: include/caffe/layers/mvn_layer.hpp
  type caffe (line 10) | namespace caffe {
    class MVNLayer (line 18) | class MVNLayer : public Layer<Dtype> {
      method MVNLayer (line 20) | explicit MVNLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 26) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 27) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/neuron_layer.hpp
  type caffe (line 10) | namespace caffe {
    class NeuronLayer (line 19) | class NeuronLayer : public Layer<Dtype> {
      method NeuronLayer (line 21) | explicit NeuronLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 26) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 27) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/normalize_layer.hpp
  type caffe (line 10) | namespace caffe {
    class NormalizeLayer (line 18) | class NormalizeLayer : public Layer<Dtype> {
      method NormalizeLayer (line 20) | explicit NormalizeLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 28) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 29) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/parameter_layer.hpp
  type caffe (line 8) | namespace caffe {
    class ParameterLayer (line 11) | class ParameterLayer : public Layer<Dtype> {
      method ParameterLayer (line 13) | explicit ParameterLayer(const LayerParameter& param)
      method LayerSetUp (line 15) | virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      method Reshape (line 26) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 29) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 30) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Forward_cpu (line 33) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 38) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/pooling_layer.hpp
  type caffe (line 10) | namespace caffe {
    class PoolingLayer (line 18) | class PoolingLayer : public Layer<Dtype> {
      method PoolingLayer (line 20) | explicit PoolingLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 28) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method MinTopBlobs (line 29) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 32) | virtual inline int MaxTopBlobs() const {

FILE: include/caffe/layers/power_layer.hpp
  type caffe (line 12) | namespace caffe {
    class PowerLayer (line 20) | class PowerLayer : public NeuronLayer<Dtype> {
      method PowerLayer (line 29) | explicit PowerLayer(const LayerParameter& param)

FILE: include/caffe/layers/prelu_layer.hpp
  type caffe (line 12) | namespace caffe {
    class PReLULayer (line 23) | class PReLULayer : public NeuronLayer<Dtype> {
      method PReLULayer (line 33) | explicit PReLULayer(const LayerParameter& param)

FILE: include/caffe/layers/python_layer.hpp
  type caffe (line 11) | namespace caffe {
    class PythonLayer (line 14) | class PythonLayer : public Layer<Dtype> {
      method PythonLayer (line 16) | PythonLayer(PyObject* self, const LayerParameter& param)
      method LayerSetUp (line 19) | virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      method Reshape (line 32) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method Forward_cpu (line 40) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 44) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/recurrent_layer.hpp
  type caffe (line 15) | namespace caffe {
    class RecurrentLayer (line 17) | class RecurrentLayer
      method RecurrentLayer (line 28) | explicit RecurrentLayer(const LayerParameter& param)
      method MinBottomBlobs (line 37) | virtual inline int MinBottomBlobs() const {
      method MaxBottomBlobs (line 46) | virtual inline int MaxBottomBlobs() const { return MinBottomBlobs() ...
      method ExactNumTopBlobs (line 47) | virtual inline int ExactNumTopBlobs() const {
      method AllowForceBackward (line 57) | virtual inline bool AllowForceBackward(const int bottom_index) const {
    class RecurrentLayer (line 26) | class RecurrentLayer : public Layer<Dtype> {
      method RecurrentLayer (line 28) | explicit RecurrentLayer(const LayerParameter& param)
      method MinBottomBlobs (line 37) | virtual inline int MinBottomBlobs() const {
      method MaxBottomBlobs (line 46) | virtual inline int MaxBottomBlobs() const { return MinBottomBlobs() ...
      method ExactNumTopBlobs (line 47) | virtual inline int ExactNumTopBlobs() const {
      method AllowForceBackward (line 57) | virtual inline bool AllowForceBackward(const int bottom_index) const {

FILE: include/caffe/layers/reduction_layer.hpp
  type caffe (line 10) | namespace caffe {
    class ReductionLayer (line 20) | class ReductionLayer : public Layer<Dtype> {
      method ReductionLayer (line 22) | explicit ReductionLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 30) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 31) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/region_loss_layer.hpp
  type caffe (line 12) | namespace caffe {
    function Dtype (line 23) | inline Dtype sigmoid(Dtype x)
    class PredictionResult (line 45) | class PredictionResult {
    type AvgRegionScore (line 58) | struct AvgRegionScore {
    class RegionLossLayer (line 69) | class RegionLossLayer : public LossLayer<Dtype> {
      method RegionLossLayer (line 71) | explicit RegionLossLayer(const LayerParameter& param)

FILE: include/caffe/layers/relu6_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ReLU6Layer (line 18) | class ReLU6Layer : public NeuronLayer<Dtype> {
      method ReLU6Layer (line 20) | explicit ReLU6Layer(const LayerParameter& param)

FILE: include/caffe/layers/relu_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ReLULayer (line 19) | class ReLULayer : public NeuronLayer<Dtype> {
      method ReLULayer (line 27) | explicit ReLULayer(const LayerParameter& param)

FILE: include/caffe/layers/reorg_layer.hpp
  type caffe (line 10) | namespace caffe {
    class ReorgLayer (line 19) | class ReorgLayer : public Layer<Dtype> {
      method ReorgLayer (line 21) | explicit ReorgLayer(const LayerParameter &param)
      method ExactNumBottomBlobs (line 32) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 34) | virtual inline int ExactNumTopBlobs() const { return 1; }
    function reorg_cpu (line 61) | void reorg_cpu(Dtype *x, int w, int h, int c, int batch, int stride, i...
    function reorg_cpu (line 85) | void reorg_cpu(const Dtype *bottom_data, const int b_w, const int b_h,

FILE: include/caffe/layers/reshape_layer.hpp
  type caffe (line 10) | namespace caffe {
    class ReshapeLayer (line 19) | class ReshapeLayer : public Layer<Dtype> {
      method ReshapeLayer (line 21) | explicit ReshapeLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 29) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 30) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Forward_cpu (line 33) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 35) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Forward_gpu (line 37) | virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_gpu (line 39) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/rnn_layer.hpp
  type caffe (line 15) | namespace caffe {
    class RecurrentLayer (line 17) | class RecurrentLayer
    class RNNLayer (line 30) | class RNNLayer : public RecurrentLayer<Dtype> {
      method RNNLayer (line 32) | explicit RNNLayer(const LayerParameter& param)

FILE: include/caffe/layers/scale_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ScaleLayer (line 26) | class ScaleLayer: public Layer<Dtype> {
      method ScaleLayer (line 28) | explicit ScaleLayer(const LayerParameter& param)
      method MinBottomBlobs (line 37) | virtual inline int MinBottomBlobs() const { return 1; }
      method MaxBottomBlobs (line 38) | virtual inline int MaxBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 39) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/sigmoid_cross_entropy_loss_layer.hpp
  type caffe (line 13) | namespace caffe {
    class SigmoidCrossEntropyLossLayer (line 45) | class SigmoidCrossEntropyLossLayer : public LossLayer<Dtype> {
      method SigmoidCrossEntropyLossLayer (line 47) | explicit SigmoidCrossEntropyLossLayer(const LayerParameter& param)

FILE: include/caffe/layers/sigmoid_layer.hpp
  type caffe (line 12) | namespace caffe {
    class SigmoidLayer (line 23) | class SigmoidLayer : public NeuronLayer<Dtype> {
      method SigmoidLayer (line 25) | explicit SigmoidLayer(const LayerParameter& param)

FILE: include/caffe/layers/silence_layer.hpp
  type caffe (line 10) | namespace caffe {
    class SilenceLayer (line 17) | class SilenceLayer : public Layer<Dtype> {
      method SilenceLayer (line 19) | explicit SilenceLayer(const LayerParameter& param)
      method Reshape (line 21) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method MinBottomBlobs (line 25) | virtual inline int MinBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 26) | virtual inline int ExactNumTopBlobs() const { return 0; }
      method Forward_cpu (line 29) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,

FILE: include/caffe/layers/slice_layer.hpp
  type caffe (line 10) | namespace caffe {
    class SliceLayer (line 19) | class SliceLayer : public Layer<Dtype> {
      method SliceLayer (line 21) | explicit SliceLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 29) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method MinTopBlobs (line 30) | virtual inline int MinTopBlobs() const { return 1; }

FILE: include/caffe/layers/smooth_L1_loss_layer.hpp
  type caffe (line 20) | namespace caffe {
    class SmoothL1LossLayer (line 27) | class SmoothL1LossLayer : public LossLayer<Dtype> {
      method SmoothL1LossLayer (line 29) | explicit SmoothL1LossLayer(const LayerParameter& param)
      method MinBottomBlobs (line 38) | virtual inline int MinBottomBlobs() const { return 2; }
      method MaxBottomBlobs (line 39) | virtual inline int MaxBottomBlobs() const { return 3; }
      method AllowForceBackward (line 45) | virtual inline bool AllowForceBackward(const int bottom_index) const {

FILE: include/caffe/layers/softmax_layer.hpp
  type caffe (line 10) | namespace caffe {
    class SoftmaxLayer (line 18) | class SoftmaxLayer : public Layer<Dtype> {
      method SoftmaxLayer (line 20) | explicit SoftmaxLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 26) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 27) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/softmax_loss_layer.hpp
  type caffe (line 13) | namespace caffe {
    class SoftmaxWithLossLayer (line 44) | class SoftmaxWithLossLayer : public LossLayer<Dtype> {
      method SoftmaxWithLossLayer (line 54) | explicit SoftmaxWithLossLayer(const LayerParameter& param)
      method ExactNumTopBlobs (line 62) | virtual inline int ExactNumTopBlobs() const { return -1; }
      method MinTopBlobs (line 63) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 64) | virtual inline int MaxTopBlobs() const { return 2; }

FILE: include/caffe/layers/split_layer.hpp
  type caffe (line 10) | namespace caffe {
    class SplitLayer (line 19) | class SplitLayer : public Layer<Dtype> {
      method SplitLayer (line 21) | explicit SplitLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 27) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method MinTopBlobs (line 28) | virtual inline int MinTopBlobs() const { return 1; }

FILE: include/caffe/layers/spp_layer.hpp
  type caffe (line 10) | namespace caffe {
    class SPPLayer (line 19) | class SPPLayer : public Layer<Dtype> {
      method SPPLayer (line 21) | explicit SPPLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 29) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 30) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/tanh_layer.hpp
  type caffe (line 12) | namespace caffe {
    class TanHLayer (line 23) | class TanHLayer : public NeuronLayer<Dtype> {
      method TanHLayer (line 25) | explicit TanHLayer(const LayerParameter& param)

FILE: include/caffe/layers/threshold_layer.hpp
  type caffe (line 12) | namespace caffe {
    class ThresholdLayer (line 19) | class ThresholdLayer : public NeuronLayer<Dtype> {
      method ThresholdLayer (line 27) | explicit ThresholdLayer(const LayerParameter& param)
      method Backward_cpu (line 54) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/tile_layer.hpp
  type caffe (line 10) | namespace caffe {
    class TileLayer (line 16) | class TileLayer : public Layer<Dtype> {
      method TileLayer (line 18) | explicit TileLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 24) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 25) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/layers/window_data_layer.hpp
  type caffe (line 15) | namespace caffe {
    class WindowDataLayer (line 25) | class WindowDataLayer : public BasePrefetchingDataLayer<Dtype> {
      method WindowDataLayer (line 27) | explicit WindowDataLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 34) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 35) | virtual inline int ExactNumTopBlobs() const { return 2; }
      type WindowField (line 43) | enum WindowField { IMAGE_INDEX, LABEL, OVERLAP, X1, Y1, X2, Y2, NUM }

FILE: include/caffe/layers/yolo_detection_output_layer.hpp
  type caffe (line 20) | namespace caffe {
    class YoloDetectionOutputLayer (line 31) | class YoloDetectionOutputLayer : public Layer<Dtype> {
      method YoloDetectionOutputLayer (line 33) | explicit YoloDetectionOutputLayer(const LayerParameter& param)
      method MinBottomBlobs (line 41) | virtual inline int MinBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 43) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Backward_cpu (line 65) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/yolov3_detection_output_layer.hpp
  type caffe (line 20) | namespace caffe {
    class Yolov3DetectionOutputLayer (line 31) | class Yolov3DetectionOutputLayer : public Layer<Dtype> {
      method Yolov3DetectionOutputLayer (line 33) | explicit Yolov3DetectionOutputLayer(const LayerParameter& param)
      method MinBottomBlobs (line 41) | virtual inline int MinBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 43) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Backward_cpu (line 65) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/layers/yolov3_layer.hpp
  type caffe (line 13) | namespace caffe {
    class Yolov3Layer (line 17) | class Yolov3Layer : public LossLayer<Dtype> {
      method Yolov3Layer (line 19) | explicit Yolov3Layer(const LayerParameter& param)
      class PredictionResult (line 28) | class PredictionResult {

FILE: include/caffe/net.hpp
  type caffe (line 15) | namespace caffe {
    class Net (line 24) | class Net {
      method Dtype (line 85) | Dtype ForwardBackward() {
      method string (line 123) | inline const string& name() const { return name_; }
      method Phase (line 137) | inline Phase phase() const { return phase_; }
      method num_inputs (line 198) | inline int num_inputs() const { return net_input_blobs_.size(); }
      method num_outputs (line 199) | inline int num_outputs() const { return net_output_blobs_.size(); }
      method set_debug_info (line 217) | void set_debug_info(const bool value) { debug_info_ = value; }
      class Callback (line 231) | class Callback {
      method add_before_forward (line 239) | void add_before_forward(Callback* value) {
      method add_after_forward (line 243) | void add_after_forward(Callback* value) {
      method add_before_backward (line 247) | void add_before_backward(Callback* value) {
      method add_after_backward (line 251) | void add_after_backward(Callback* value) {

FILE: include/caffe/parallel.hpp
  type caffe (line 21) | namespace caffe {
    class Params (line 27) | class Params {
      method size (line 33) | inline size_t size() const {
      method Dtype (line 36) | inline Dtype* data() const {
      method Dtype (line 39) | inline Dtype* diff() const {
    class GPUParams (line 53) | class GPUParams : public Params<Dtype> {
    class NCCL (line 67) | class NCCL : public GPUParams<Dtype>,
      method on_start (line 105) | void on_start() {}

FILE: include/caffe/sgd_solvers.hpp
  type caffe (line 9) | namespace caffe {
    class SGDSolver (line 16) | class SGDSolver : public Solver<Dtype> {
      method SGDSolver (line 18) | explicit SGDSolver(const SolverParameter& param)
      method SGDSolver (line 20) | explicit SGDSolver(const string& param_file)
    class NesterovSolver (line 50) | class NesterovSolver : public SGDSolver<Dtype> {
      method NesterovSolver (line 52) | explicit NesterovSolver(const SolverParameter& param)
      method NesterovSolver (line 54) | explicit NesterovSolver(const string& param_file)
    class AdaGradSolver (line 65) | class AdaGradSolver : public SGDSolver<Dtype> {
      method AdaGradSolver (line 67) | explicit AdaGradSolver(const SolverParameter& param)
      method AdaGradSolver (line 69) | explicit AdaGradSolver(const string& param_file)
      method constructor_sanity_check (line 75) | void constructor_sanity_check() {
    class RMSPropSolver (line 85) | class RMSPropSolver : public SGDSolver<Dtype> {
      method RMSPropSolver (line 87) | explicit RMSPropSolver(const SolverParameter& param)
      method RMSPropSolver (line 89) | explicit RMSPropSolver(const string& param_file)
      method constructor_sanity_check (line 95) | void constructor_sanity_check() {
    class AdaDeltaSolver (line 108) | class AdaDeltaSolver : public SGDSolver<Dtype> {
      method AdaDeltaSolver (line 110) | explicit AdaDeltaSolver(const SolverParameter& param)
      method AdaDeltaSolver (line 112) | explicit AdaDeltaSolver(const string& param_file)
    class AdamSolver (line 132) | class AdamSolver : public SGDSolver<Dtype> {
      method AdamSolver (line 134) | explicit AdamSolver(const SolverParameter& param)
      method AdamSolver (line 136) | explicit AdamSolver(const string& param_file)

FILE: include/caffe/solver.hpp
  type caffe (line 11) | namespace caffe {
    type SolverAction (line 21) | namespace SolverAction {
      type Enum (line 22) | enum Enum {
    class Solver (line 42) | class Solver {
      method Solve (line 58) | inline void Solve(const string resume_file) { Solve(resume_file.c_st...
      method SolverParameter (line 70) | inline const SolverParameter& param() const { return param_; }
      method net (line 71) | inline shared_ptr<Net<Dtype> > net() { return net_; }
      method iter (line 75) | int iter() const { return iter_; }
      class Callback (line 78) | class Callback {
      method add_callback (line 87) | void add_callback(Callback* value) {

FILE: include/caffe/solver_factory.hpp
  type caffe (line 48) | namespace caffe {
    class Solver (line 51) | class Solver
    class SolverRegistry (line 54) | class SolverRegistry {
    class SolverRegisterer (line 78) | class SolverRegisterer {

FILE: include/caffe/syncedmem.hpp
  type caffe (line 12) | namespace caffe {
    function CaffeMallocHost (line 19) | inline void CaffeMallocHost(void** ptr, size_t size, bool* use_cuda) {
    function CaffeFreeHost (line 36) | inline void CaffeFreeHost(void* ptr, bool use_cuda) {
    class SyncedMemory (line 57) | class SyncedMemory {
      type SyncedHead (line 68) | enum SyncedHead { UNINITIALIZED, HEAD_AT_CPU, HEAD_AT_GPU, SYNCED }
      method SyncedHead (line 69) | SyncedHead head() const { return head_; }
      method size (line 70) | size_t size() const { return size_; }

FILE: include/caffe/test/test_caffe_main.hpp
  type caffe (line 28) | namespace caffe {
    class MultiDeviceTest (line 31) | class MultiDeviceTest : public ::testing::Test {
      method MultiDeviceTest (line 35) | MultiDeviceTest() {
    type CPUDevice (line 44) | struct CPUDevice {
    class CPUDeviceTest (line 50) | class CPUDeviceTest : public MultiDeviceTest<CPUDevice<Dtype> > {
    type GPUDevice (line 61) | struct GPUDevice {
    class GPUDeviceTest (line 67) | class GPUDeviceTest : public MultiDeviceTest<GPUDevice<Dtype> > {

FILE: include/caffe/test/test_gradient_check_util.hpp
  type caffe (line 14) | namespace caffe {
    class GradientChecker (line 19) | class GradientChecker {
      method GradientChecker (line 24) | GradientChecker(const Dtype stepsize, const Dtype threshold,
      method CheckGradient (line 33) | void CheckGradient(Layer<Dtype>* layer, const vector<Blob<Dtype>*>& ...
    function Dtype (line 233) | Dtype GradientChecker<Dtype>::GetObjAndGradient(const Layer<Dtype>& la...

FILE: include/caffe/util/bbox_util.hpp
  type caffe (line 21) | namespace caffe {

FILE: include/caffe/util/benchmark.hpp
  type caffe (line 8) | namespace caffe {
    class Timer (line 10) | class Timer {
      method initted (line 20) | inline bool initted() { return initted_; }
      method running (line 21) | inline bool running() { return running_; }
      method has_run_at_least_once (line 22) | inline bool has_run_at_least_once() { return has_run_at_least_once_; }
    class CPUTimer (line 40) | class CPUTimer : public Timer {

FILE: include/caffe/util/blocking_queue.hpp
  type caffe (line 7) | namespace caffe {
    class BlockingQueue (line 10) | class BlockingQueue {
      class sync (line 35) | class sync

FILE: include/caffe/util/cudnn.hpp
  type caffe (line 54) | namespace caffe {
    type cudnn (line 56) | namespace cudnn {
      class dataType (line 58) | class dataType
      class dataType<float> (line 59) | class dataType<float>  {
      class dataType<double> (line 65) | class dataType<double> {
      function createTensor4dDesc (line 73) | inline void createTensor4dDesc(cudnnTensorDescriptor_t* desc) {
      function setTensor4dDesc (line 78) | inline void setTensor4dDesc(cudnnTensorDescriptor_t* desc,
      function setTensor4dDesc (line 86) | inline void setTensor4dDesc(cudnnTensorDescriptor_t* desc,
      function createFilterDesc (line 97) | inline void createFilterDesc(cudnnFilterDescriptor_t* desc,
      function createConvolutionDesc (line 110) | inline void createConvolutionDesc(cudnnConvolutionDescriptor_t* conv) {
      function setConvolutionDesc (line 115) | inline void setConvolutionDesc(cudnnConvolutionDescriptor_t* conv,
      function createPoolingDesc (line 129) | inline void createPoolingDesc(cudnnPoolingDescriptor_t* pool_desc,
      function createActivationDescriptor (line 153) | inline void createActivationDescriptor(cudnnActivationDescriptor_t* ...

FILE: include/caffe/util/db.hpp
  type caffe (line 9) | namespace caffe { namespace db {
    type db (line 9) | namespace db {
      type Mode (line 11) | enum Mode { READ, WRITE, NEW }
      class Cursor (line 13) | class Cursor {
        method Cursor (line 15) | Cursor() { }
      class Transaction (line 26) | class Transaction {
        method Transaction (line 28) | Transaction() { }
      class DB (line 36) | class DB {
        method DB (line 38) | DB() { }

FILE: include/caffe/util/db_leveldb.hpp
  type caffe (line 12) | namespace caffe { namespace db {
    type db (line 12) | namespace db {
      class LevelDBCursor (line 14) | class LevelDBCursor : public Cursor {
        method LevelDBCursor (line 16) | explicit LevelDBCursor(leveldb::Iterator* iter)
        method SeekToFirst (line 22) | virtual void SeekToFirst() { iter_->SeekToFirst(); }
        method Next (line 23) | virtual void Next() { iter_->Next(); }
        method string (line 24) | virtual string key() { return iter_->key().ToString(); }
        method string (line 25) | virtual string value() { return iter_->value().ToString(); }
        method valid (line 26) | virtual bool valid() { return iter_->Valid(); }
      class LevelDBTransaction (line 32) | class LevelDBTransaction : public Transaction {
        method LevelDBTransaction (line 34) | explicit LevelDBTransaction(leveldb::DB* db) : db_(db) { CHECK_NOT...
        method Put (line 35) | virtual void Put(const string& key, const string& value) {
        method Commit (line 38) | virtual void Commit() {
      class LevelDB (line 51) | class LevelDB : public DB {
        method LevelDB (line 53) | LevelDB() : db_(NULL) { }
        method Close (line 56) | virtual void Close() {
        method LevelDBCursor (line 62) | virtual LevelDBCursor* NewCursor() {
        method LevelDBTransaction (line 65) | virtual LevelDBTransaction* NewTransaction() {

FILE: include/caffe/util/db_lmdb.hpp
  type caffe (line 12) | namespace caffe { namespace db {
    type db (line 12) | namespace db {
      function MDB_CHECK (line 14) | inline void MDB_CHECK(int mdb_status) {
      class LMDBCursor (line 18) | class LMDBCursor : public Cursor {
        method LMDBCursor (line 20) | explicit LMDBCursor(MDB_txn* mdb_txn, MDB_cursor* mdb_cursor)
        method SeekToFirst (line 28) | virtual void SeekToFirst() { Seek(MDB_FIRST); }
        method Next (line 29) | virtual void Next() { Seek(MDB_NEXT); }
        method string (line 30) | virtual string key() {
        method string (line 33) | virtual string value() {
        method valid (line 37) | virtual bool valid() { return valid_; }
        method Seek (line 40) | void Seek(MDB_cursor_op op) {
      class LMDBTransaction (line 56) | class LMDBTransaction : public Transaction {
        method LMDBTransaction (line 58) | explicit LMDBTransaction(MDB_env* mdb_env)
      class LMDB (line 72) | class LMDB : public DB {
        method LMDB (line 74) | LMDB() : mdb_env_(NULL) { }
        method Close (line 77) | virtual void Close() {

FILE: include/caffe/util/device_alternate.hpp
  type caffe (line 78) | namespace caffe {
    function CAFFE_GET_BLOCKS (line 88) | inline int CAFFE_GET_BLOCKS(const int N) {

FILE: include/caffe/util/format.hpp
  type caffe (line 8) | namespace caffe {
    function format_int (line 10) | inline std::string format_int(int n, int numberOfLeadingZeros = 0 ) {

FILE: include/caffe/util/hdf5.hpp
  type caffe (line 11) | namespace caffe {

FILE: include/caffe/util/im2col.hpp
  type caffe (line 4) | namespace caffe {

FILE: include/caffe/util/im_transforms.hpp
  type caffe (line 14) | namespace caffe {

FILE: include/caffe/util/insert_splits.hpp
  type caffe (line 8) | namespace caffe {

FILE: include/caffe/util/io.hpp
  type caffe (line 20) | namespace caffe {
    function MakeTempDir (line 25) | inline void MakeTempDir(string* temp_dirname) {
    function MakeTempFilename (line 40) | inline void MakeTempFilename(string* temp_filename) {
    function GetTempDirname (line 53) | inline void GetTempDirname(string* temp_dirname) {
    function GetTempFilename (line 72) | inline void GetTempFilename(string* temp_filename) {
    function ReadProtoFromTextFile (line 87) | inline bool ReadProtoFromTextFile(const string& filename, Message* pro...
    function ReadProtoFromTextFileOrDie (line 91) | inline void ReadProtoFromTextFileOrDie(const char* filename, Message* ...
    function ReadProtoFromTextFileOrDie (line 95) | inline void ReadProtoFromTextFileOrDie(const string& filename, Message...
    function WriteProtoToTextFile (line 100) | inline void WriteProtoToTextFile(const Message& proto, const string& f...
    function ReadProtoFromBinaryFile (line 106) | inline bool ReadProtoFromBinaryFile(const string& filename, Message* p...
    function ReadProtoFromBinaryFileOrDie (line 110) | inline void ReadProtoFromBinaryFileOrDie(const char* filename, Message...
    function ReadProtoFromBinaryFileOrDie (line 114) | inline void ReadProtoFromBinaryFileOrDie(const string& filename,
    function WriteProtoToBinaryFile (line 121) | inline void WriteProtoToBinaryFile(
    function ReadFileToDatum (line 128) | inline bool ReadFileToDatum(const string& filename, Datum* datum) {
    function ReadImageToDatum (line 136) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 143) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 150) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 157) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 163) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 168) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 173) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 178) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadRichImageToAnnotatedDatum (line 196) | inline bool ReadRichImageToAnnotatedDatum(const string& filename,
    function ReadLabelFileToLabelMap (line 220) | inline bool ReadLabelFileToLabelMap(const string& filename,
    function ReadLabelFileToLabelMap (line 225) | inline bool ReadLabelFileToLabelMap(const string& filename, LabelMap* ...
    function MapNameToLabel (line 232) | inline bool MapNameToLabel(const LabelMap& map,
    function MapLabelToName (line 240) | inline bool MapLabelToName(const LabelMap& map,
    function MapLabelToDisplayName (line 248) | inline bool MapLabelToDisplayName(const LabelMap& map,

FILE: include/caffe/util/math_functions.hpp
  type caffe (line 13) | namespace caffe {
    function logistic_activate (line 15) | static inline float logistic_activate(float x) { return 1. / (1. + exp...
    function logistic_gradient (line 16) | static inline float logistic_gradient(float x) { return (1 - x)*x; }
    function caffe_memset (line 51) | inline void caffe_memset(const size_t N, const int alpha, void* X) {
    function caffe_sign (line 123) | inline int8_t caffe_sign(Dtype val) {
    function caffe_gpu_memset (line 186) | inline void caffe_gpu_memset(const size_t N, const int alpha, void* X) {

FILE: include/caffe/util/mkl_alternate.hpp
  function cblas_saxpby (line 89) | inline void cblas_saxpby(const int N, const float alpha, const float* X,
  function cblas_daxpby (line 95) | inline void cblas_daxpby(const int N, const double alpha, const double* X,

FILE: include/caffe/util/nccl.hpp
  type caffe (line 16) | namespace caffe {
    type nccl (line 18) | namespace nccl {
      class dataType (line 20) | class dataType
      class dataType<float> (line 22) | class dataType<float> {
      class dataType<double> (line 26) | class dataType<double> {

FILE: include/caffe/util/rng.hpp
  type caffe (line 12) | namespace caffe {
    function rng_t (line 16) | inline rng_t* caffe_rng() {
    function shuffle (line 22) | inline void shuffle(RandomAccessIterator begin, RandomAccessIterator end,
    function shuffle (line 38) | inline void shuffle(RandomAccessIterator begin, RandomAccessIterator e...

FILE: include/caffe/util/sampler.hpp
  type caffe (line 10) | namespace caffe {

FILE: include/caffe/util/signal_handler.h
  function namespace (line 7) | namespace caffe {

FILE: include/caffe/util/upgrade_proto.hpp
  type caffe (line 8) | namespace caffe {

FILE: matlab/+caffe/private/caffe_.cpp
  function mxCHECK (line 25) | inline void mxCHECK(bool expr, const char* msg) {
  function mxERROR (line 30) | inline void mxERROR(const char* msg) { mexErrMsgTxt(msg); }
  function mxCHECK_FILE_EXIST (line 33) | void mxCHECK_FILE_EXIST(const char* file) {
  type WhichMemory (line 61) | enum WhichMemory { DATA, DIFF }
  function mx_mat_to_blob (line 64) | static void mx_mat_to_blob(const mxArray* mx_mat, Blob<float>* blob,
  function mxArray (line 86) | static mxArray* blob_to_mx_mat(const Blob<float>* blob,
  function mxArray (line 117) | static mxArray* int_vec_to_mx_vec(const vector<int>& int_vec) {
  function mxArray (line 127) | static mxArray* str_vec_to_mx_strcell(const vector<std::string>& str_vec) {
  function T (line 143) | static T* handle_to_ptr(const mxArray* mx_handle) {
  function mxArray (line 155) | static mxArray* create_handle_vec(int ptr_num) {
  function setup_handle (line 163) | static void setup_handle(const T* ptr, int index, mxArray* mx_handle_vec) {
  function mxArray (line 173) | static mxArray* ptr_to_handle(const T* ptr) {
  function mxArray (line 181) | static mxArray* ptr_vec_to_handle_vec(const vector<shared_ptr<T> >& ptr_...
  function get_solver (line 193) | static void get_solver(MEX_ARGS) {
  function delete_solver (line 208) | static void delete_solver(MEX_ARGS) {
  function solver_get_attr (line 219) | static void solver_get_attr(MEX_ARGS) {
  function solver_get_iter (line 235) | static void solver_get_iter(MEX_ARGS) {
  function solver_restore (line 243) | static void solver_restore(MEX_ARGS) {
  function solver_solve (line 254) | static void solver_solve(MEX_ARGS) {
  function solver_step (line 262) | static void solver_step(MEX_ARGS) {
  function get_net (line 271) | static void get_net(MEX_ARGS) {
  function delete_net (line 293) | static void delete_net(MEX_ARGS) {
  function net_get_attr (line 304) | static void net_get_attr(MEX_ARGS) {
  function net_forward (line 329) | static void net_forward(MEX_ARGS) {
  function net_backward (line 337) | static void net_backward(MEX_ARGS) {
  function net_copy_from (line 345) | static void net_copy_from(MEX_ARGS) {
  function net_reshape (line 356) | static void net_reshape(MEX_ARGS) {
  function net_save (line 364) | static void net_save(MEX_ARGS) {
  function layer_get_attr (line 376) | static void layer_get_attr(MEX_ARGS) {
  function layer_get_type (line 390) | static void layer_get_type(MEX_ARGS) {
  function blob_get_shape (line 398) | static void blob_get_shape(MEX_ARGS) {
  function blob_reshape (line 413) | static void blob_reshape(MEX_ARGS) {
  function blob_get_data (line 429) | static void blob_get_data(MEX_ARGS) {
  function blob_set_data (line 437) | static void blob_set_data(MEX_ARGS) {
  function blob_get_diff (line 445) | static void blob_get_diff(MEX_ARGS) {
  function blob_set_diff (line 453) | static void blob_set_diff(MEX_ARGS) {
  function set_mode_cpu (line 461) | static void set_mode_cpu(MEX_ARGS) {
  function set_mode_gpu (line 467) | static void set_mode_gpu(MEX_ARGS) {
  function set_device (line 473) | static void set_device(MEX_ARGS) {
  function get_init_key (line 481) | static void get_init_key(MEX_ARGS) {
  function reset (line 487) | static void reset(MEX_ARGS) {
  function read_mean (line 499) | static void read_mean(MEX_ARGS) {
  function write_mean (line 514) | static void write_mean(MEX_ARGS) {
  function version (line 537) | static void version(MEX_ARGS) {
  type handler_registry (line 546) | struct handler_registry {
  function mexFunction (line 592) | void mexFunction(MEX_ARGS) {

FILE: python/caffe/_caffe.cpp
  type caffe (line 57) | namespace caffe {
    class NCCL (line 58) | class NCCL
      method NCCL (line 382) | NCCL(shared_ptr<Solver<Dtype> > solver, const string& uid) {}
    function set_mode_cpu (line 84) | void set_mode_cpu() { Caffe::set_mode(Caffe::CPU); }
    function set_mode_gpu (line 85) | void set_mode_gpu() { Caffe::set_mode(Caffe::GPU); }
    function InitLog (line 87) | void InitLog() {
    function InitLogLevel (line 94) | void InitLogLevel(int level) {
    function InitLogLevelPipe (line 98) | void InitLogLevelPipe(int level, bool std_err) {
    function Log (line 103) | void Log(const string& s) {
    function set_random_seed (line 107) | void set_random_seed(unsigned int seed) { Caffe::set_random_seed(seed); }
    function CheckFile (line 113) | static void CheckFile(const string& filename) {
    function CheckContiguousArray (line 122) | void CheckContiguousArray(PyArrayObject* arr, string name,
    function Net_Init (line 145) | shared_ptr<Net<Dtype> > Net_Init(string network_file, int phase,
    function Net_Init_Load (line 173) | shared_ptr<Net<Dtype> > Net_Init_Load(
    function Net_Save (line 189) | void Net_Save(const Net<Dtype>& net, string filename) {
    function Net_SaveHDF5 (line 195) | void Net_SaveHDF5(const Net<Dtype>& net, string filename) {
    function Net_LoadHDF5 (line 199) | void Net_LoadHDF5(Net<Dtype>* net, string filename) {
    function Net_SetInputArrays (line 203) | void Net_SetInputArrays(Net<Dtype>* net, bp::object data_obj,
    type NdarrayConverterGenerator (line 241) | struct NdarrayConverterGenerator {
      type apply (line 242) | struct apply
    type NdarrayConverterGenerator::apply<Dtype*> (line 246) | struct NdarrayConverterGenerator::apply<Dtype*> {
      type type (line 247) | struct type {
        method PyObject (line 248) | PyObject* operator() (Dtype* data) const {
        method PyTypeObject (line 252) | const PyTypeObject* get_pytype() {
    type NdarrayCallPolicies (line 258) | struct NdarrayCallPolicies : public bp::default_call_policies {
      method PyObject (line 260) | PyObject* postcall(PyObject* pyargs, PyObject* result) {
    function Blob_Reshape (line 280) | bp::object Blob_Reshape(bp::tuple args, bp::dict kwargs) {
    function BlobVec_add_blob (line 294) | bp::object BlobVec_add_blob(bp::tuple args, bp::dict kwargs) {
    class SolverCallback (line 310) | class SolverCallback: public Solver<Dtype>::Callback {
      method SolverCallback (line 315) | SolverCallback(bp::object on_start, bp::object on_gradients_ready)
      method on_gradients_ready (line 317) | virtual void on_gradients_ready() {
      method on_start (line 320) | virtual void on_start() {
    function Solver_add_callback (line 325) | void Solver_add_callback(Solver<Dtype> * solver, bp::object on_start,
    function share_weights (line 341) | void share_weights(Solver<Dtype>* solver, Net<Dtype>* net) {
    class NetCallback (line 346) | class NetCallback: public Net<Dtype>::Callback {
      method NetCallback (line 348) | explicit NetCallback(bp::object run) : run_(run) {}
      method run (line 351) | virtual void run(int layer) {
    function Net_before_forward (line 356) | void Net_before_forward(Net<Dtype>* net, bp::object run) {
    function Net_after_forward (line 359) | void Net_after_forward(Net<Dtype>* net, bp::object run) {
    function Net_before_backward (line 362) | void Net_before_backward(Net<Dtype>* net, bp::object run) {
    function Net_after_backward (line 365) | void Net_after_backward(Net<Dtype>* net, bp::object run) {
    class NCCL (line 380) | class NCCL {
      method NCCL (line 382) | NCCL(shared_ptr<Solver<Dtype> > solver, const string& uid) {}
    function HasNCCL (line 386) | bool HasNCCL() {
    function NCCL_New_Uid (line 395) | bp::object NCCL_New_Uid() {
    function BOOST_PYTHON_MODULE (line 417) | BOOST_PYTHON_MODULE(_caffe) {
  type caffe (line 77) | namespace caffe {
    class NCCL (line 58) | class NCCL
      method NCCL (line 382) | NCCL(shared_ptr<Solver<Dtype> > solver, const string& uid) {}
    function set_mode_cpu (line 84) | void set_mode_cpu() { Caffe::set_mode(Caffe::CPU); }
    function set_mode_gpu (line 85) | void set_mode_gpu() { Caffe::set_mode(Caffe::GPU); }
    function InitLog (line 87) | void InitLog() {
    function InitLogLevel (line 94) | void InitLogLevel(int level) {
    function InitLogLevelPipe (line 98) | void InitLogLevelPipe(int level, bool std_err) {
    function Log (line 103) | void Log(const string& s) {
    function set_random_seed (line 107) | void set_random_seed(unsigned int seed) { Caffe::set_random_seed(seed); }
    function CheckFile (line 113) | static void CheckFile(const string& filename) {
    function CheckContiguousArray (line 122) | void CheckContiguousArray(PyArrayObject* arr, string name,
    function Net_Init (line 145) | shared_ptr<Net<Dtype> > Net_Init(string network_file, int phase,
    function Net_Init_Load (line 173) | shared_ptr<Net<Dtype> > Net_Init_Load(
    function Net_Save (line 189) | void Net_Save(const Net<Dtype>& net, string filename) {
    function Net_SaveHDF5 (line 195) | void Net_SaveHDF5(const Net<Dtype>& net, string filename) {
    function Net_LoadHDF5 (line 199) | void Net_LoadHDF5(Net<Dtype>* net, string filename) {
    function Net_SetInputArrays (line 203) | void Net_SetInputArrays(Net<Dtype>* net, bp::object data_obj,
    type NdarrayConverterGenerator (line 241) | struct NdarrayConverterGenerator {
      type apply (line 242) | struct apply
    type NdarrayConverterGenerator::apply<Dtype*> (line 246) | struct NdarrayConverterGenerator::apply<Dtype*> {
      type type (line 247) | struct type {
        method PyObject (line 248) | PyObject* operator() (Dtype* data) const {
        method PyTypeObject (line 252) | const PyTypeObject* get_pytype() {
    type NdarrayCallPolicies (line 258) | struct NdarrayCallPolicies : public bp::default_call_policies {
      method PyObject (line 260) | PyObject* postcall(PyObject* pyargs, PyObject* result) {
    function Blob_Reshape (line 280) | bp::object Blob_Reshape(bp::tuple args, bp::dict kwargs) {
    function BlobVec_add_blob (line 294) | bp::object BlobVec_add_blob(bp::tuple args, bp::dict kwargs) {
    class SolverCallback (line 310) | class SolverCallback: public Solver<Dtype>::Callback {
      method SolverCallback (line 315) | SolverCallback(bp::object on_start, bp::object on_gradients_ready)
      method on_gradients_ready (line 317) | virtual void on_gradients_ready() {
      method on_start (line 320) | virtual void on_start() {
    function Solver_add_callback (line 325) | void Solver_add_callback(Solver<Dtype> * solver, bp::object on_start,
    function share_weights (line 341) | void share_weights(Solver<Dtype>* solver, Net<Dtype>* net) {
    class NetCallback (line 346) | class NetCallback: public Net<Dtype>::Callback {
      method NetCallback (line 348) | explicit NetCallback(bp::object run) : run_(run) {}
      method run (line 351) | virtual void run(int layer) {
    function Net_before_forward (line 356) | void Net_before_forward(Net<Dtype>* net, bp::object run) {
    function Net_after_forward (line 359) | void Net_after_forward(Net<Dtype>* net, bp::object run) {
    function Net_before_backward (line 362) | void Net_before_backward(Net<Dtype>* net, bp::object run) {
    function Net_after_backward (line 365) | void Net_after_backward(Net<Dtype>* net, bp::object run) {
    class NCCL (line 380) | class NCCL {
      method NCCL (line 382) | NCCL(shared_ptr<Solver<Dtype> > solver, const string& uid) {}
    function HasNCCL (line 386) | bool HasNCCL() {
    function NCCL_New_Uid (line 395) | bp::object NCCL_New_Uid() {
    function BOOST_PYTHON_MODULE (line 417) | BOOST_PYTHON_MODULE(_caffe) {

FILE: python/caffe/classifier.py
  class Classifier (line 11) | class Classifier(caffe.Net):
    method __init__ (line 23) | def __init__(self, model_file, pretrained_file, image_dims=None,
    method predict (line 47) | def predict(self, inputs, oversample=True):

FILE: python/caffe/coord_map.py
  function conv_params (line 18) | def conv_params(fn):
  function crop_params (line 40) | def crop_params(fn):
  class UndefinedMapException (line 50) | class UndefinedMapException(Exception):
  function coord_map (line 57) | def coord_map(fn):
  class AxisMismatchException (line 82) | class AxisMismatchException(Exception):
  function compose (line 89) | def compose(base_map, next_map):
  function inverse (line 106) | def inverse(coord_map):
  function coord_map_from_to (line 115) | def coord_map_from_to(top_from, top_to):
  function crop (line 172) | def crop(top_from, top_to):

FILE: python/caffe/detector.py
  class Detector (line 22) | class Detector(caffe.Net):
    method __init__ (line 35) | def __init__(self, model_file, pretrained_file, mean=None,
    method detect_windows (line 56) | def detect_windows(self, images_windows):
    method detect_selective_search (line 101) | def detect_selective_search(self, image_fnames):
    method crop (line 125) | def crop(self, im, window):
    method configure_crop (line 181) | def configure_crop(self, context_pad):

FILE: python/caffe/draw.py
  function resolve_graphviz_executables (line 33) | def resolve_graphviz_executables():
  function get_pooling_types_dict (line 66) | def get_pooling_types_dict():
  function get_edge_label (line 76) | def get_edge_label(layer):
  function get_layer_label (line 92) | def get_layer_label(layer, rankdir):
  function choose_color_by_layertype (line 147) | def choose_color_by_layertype(layertype):
  function get_pydot_graph (line 160) | def get_pydot_graph(caffe_net, rankdir, label_edges=True, phase=None):
  function draw_net (line 235) | def draw_net(caffe_net, rankdir, ext='png', phase=None):
  function draw_net_to_file (line 256) | def draw_net_to_file(caffe_net, filename, rankdir='LR', phase=None):

FILE: python/caffe/io.py
  function blobproto_to_array (line 18) | def blobproto_to_array(blob, return_diff=False):
  function array_to_blobproto (line 36) | def array_to_blobproto(arr, diff=None):
  function arraylist_to_blobprotovector_str (line 49) | def arraylist_to_blobprotovector_str(arraylist):
  function blobprotovector_str_to_arraylist (line 58) | def blobprotovector_str_to_arraylist(str):
  function array_to_datum (line 66) | def array_to_datum(arr, label=None):
  function datum_to_array (line 84) | def datum_to_array(datum):
  class Transformer (line 98) | class Transformer:
    method __init__ (line 109) | def __init__(self, inputs):
    method __check_input (line 117) | def __check_input(self, in_):
    method preprocess (line 122) | def preprocess(self, in_, data):
    method deprocess (line 164) | def deprocess(self, in_, data):
    method set_transpose (line 187) | def set_transpose(self, in_, order):
    method set_channel_swap (line 203) | def set_channel_swap(self, in_, order):
    method set_raw_scale (line 221) | def set_raw_scale(self, in_, scale):
    method set_mean (line 236) | def set_mean(self, in_, mean):
    method set_input_scale (line 262) | def set_input_scale(self, in_, scale):
  function load_image (line 279) | def load_image(filename, color=True):
  function resize_image (line 306) | def resize_image(im, new_dims, interp_order=1):
  function oversample (line 341) | def oversample(images, crop_dims):

FILE: python/caffe/net_spec.py
  function param_name_dict (line 28) | def param_name_dict():
  function to_proto (line 43) | def to_proto(*tops):
  function assign_proto (line 56) | def assign_proto(proto, name, val):
  class Top (line 82) | class Top(object):
    method __init__ (line 86) | def __init__(self, fn, n):
    method to_proto (line 90) | def to_proto(self):
    method _to_proto (line 96) | def _to_proto(self, layers, names, autonames):
  class Function (line 100) | class Function(object):
    method __init__ (line 104) | def __init__(self, type_name, inputs, params):
    method _get_name (line 121) | def _get_name(self, names, autonames):
    method _get_top_name (line 129) | def _get_top_name(self, top, names, autonames):
    method _to_proto (line 135) | def _to_proto(self, layers, names, autonames):
  class NetSpec (line 167) | class NetSpec(object):
    method __init__ (line 173) | def __init__(self):
    method __setattr__ (line 176) | def __setattr__(self, name, value):
    method __getattr__ (line 179) | def __getattr__(self, name):
    method __setitem__ (line 182) | def __setitem__(self, key, value):
    method __getitem__ (line 185) | def __getitem__(self, item):
    method to_proto (line 188) | def to_proto(self):
  class Layers (line 199) | class Layers(object):
    method __getattr__ (line 204) | def __getattr__(self, name):
  class Parameters (line 216) | class Parameters(object):
    method __getattr__ (line 221) | def __getattr__(self, name):

FILE: python/caffe/pycaffe.py
  function _Net_blobs (line 25) | def _Net_blobs(self):
  function _Net_blob_loss_weights (line 36) | def _Net_blob_loss_weights(self):
  function _Net_layer_dict (line 47) | def _Net_layer_dict(self):
  function _Net_params (line 58) | def _Net_params(self):
  function _Net_inputs (line 73) | def _Net_inputs(self):
  function _Net_outputs (line 81) | def _Net_outputs(self):
  function _Net_forward (line 88) | def _Net_forward(self, blobs=None, start=None, end=None, **kwargs):
  function _Net_backward (line 137) | def _Net_backward(self, diffs=None, start=None, end=None, **kwargs):
  function _Net_forward_all (line 185) | def _Net_forward_all(self, blobs=None, **kwargs):
  function _Net_forward_backward_all (line 216) | def _Net_forward_backward_all(self, blobs=None, diffs=None, **kwargs):
  function _Net_set_input_arrays (line 261) | def _Net_set_input_arrays(self, data, labels):
  function _Net_batch (line 272) | def _Net_batch(self, blobs):
  function _Net_get_id_name (line 305) | def _Net_get_id_name(func, field):

FILE: python/caffe/test/test_coord_map.py
  function coord_net_spec (line 12) | def coord_net_spec(ks=3, stride=1, pad=0, pool=2, dstride=2, dpad=0):
  class TestCoordMap (line 34) | class TestCoordMap(unittest.TestCase):
    method setUp (line 35) | def setUp(self):
    method test_conv_pool_deconv (line 38) | def test_conv_pool_deconv(self):
    method test_pass (line 55) | def test_pass(self):
    method test_padding (line 71) | def test_padding(self):
    method test_multi_conv (line 94) | def test_multi_conv(self):
    method test_rect (line 109) | def test_rect(self):
    method test_nd_conv (line 125) | def test_nd_conv(self):
    method test_crop_of_crop (line 146) | def test_crop_of_crop(self):
    method test_crop_helper (line 160) | def test_crop_helper(self):
    method test_catch_unconnected (line 167) | def test_catch_unconnected(self):
    method test_catch_scale_mismatch (line 176) | def test_catch_scale_mismatch(self):
    method test_catch_negative_crop (line 185) | def test_catch_negative_crop(self):

FILE: python/caffe/test/test_draw.py
  function getFilenames (line 9) | def getFilenames():
  class TestDraw (line 27) | class TestDraw(unittest.TestCase):
    method test_draw_net (line 28) | def test_draw_net(self):

FILE: python/caffe/test/test_io.py
  class TestBlobProtoToArray (line 6) | class TestBlobProtoToArray(unittest.TestCase):
    method test_old_format (line 8) | def test_old_format(self):
    method test_new_format (line 18) | def test_new_format(self):
    method test_no_shape (line 27) | def test_no_shape(self):
    method test_scalar (line 35) | def test_scalar(self):
  class TestArrayToDatum (line 44) | class TestArrayToDatum(unittest.TestCase):
    method test_label_none_size (line 46) | def test_label_none_size(self):

FILE: python/caffe/test/test_layer_type_list.py
  class TestLayerTypeList (line 5) | class TestLayerTypeList(unittest.TestCase):
    method test_standard_types (line 7) | def test_standard_types(self):

FILE: python/caffe/test/test_nccl.py
  class TestNCCL (line 7) | class TestNCCL(unittest.TestCase):
    method test_newuid (line 9) | def test_newuid(self):

FILE: python/caffe/test/test_net.py
  function simple_net_file (line 11) | def simple_net_file(num_output):
  class TestNet (line 38) | class TestNet(unittest.TestCase):
    method setUp (line 39) | def setUp(self):
    method test_memory (line 49) | def test_memory(self):
    method test_layer_dict (line 63) | def test_layer_dict(self):
    method test_forward_backward (line 70) | def test_forward_backward(self):
    method test_forward_start_end (line 74) | def test_forward_start_end(self):
    method test_backward_start_end (line 92) | def test_backward_start_end(self):
    method test_clear_param_diffs (line 111) | def test_clear_param_diffs(self):
    method test_inputs_outputs (line 122) | def test_inputs_outputs(self):
    method test_top_bottom_names (line 126) | def test_top_bottom_names(self):
    method test_save_and_read (line 138) | def test_save_and_read(self):
    method test_save_hdf5 (line 155) | def test_save_hdf5(self):
  class TestLevels (line 169) | class TestLevels(unittest.TestCase):
    method setUp (line 219) | def setUp(self):
    method tearDown (line 224) | def tearDown(self):
    method check_net (line 227) | def check_net(self, net, blobs):
    method test_0 (line 231) | def test_0(self):
    method test_1 (line 235) | def test_1(self):
  class TestStages (line 240) | class TestStages(unittest.TestCase):
    method setUp (line 284) | def setUp(self):
    method tearDown (line 289) | def tearDown(self):
    method check_net (line 292) | def check_net(self, net, blobs):
    method test_A (line 296) | def test_A(self):
    method test_B (line 300) | def test_B(self):
    method test_AandB (line 304) | def test_AandB(self):
  class TestAllInOne (line 309) | class TestAllInOne(unittest.TestCase):
    method setUp (line 366) | def setUp(self):
    method tearDown (line 371) | def tearDown(self):
    method check_net (line 374) | def check_net(self, net, outputs):
    method test_train (line 378) | def test_train(self):
    method test_val (line 382) | def test_val(self):
    method test_deploy (line 386) | def test_deploy(self):

FILE: python/caffe/test/test_net_spec.py
  function lenet (line 7) | def lenet(batch_size):
  function anon_lenet (line 26) | def anon_lenet(batch_size):
  function silent_net (line 44) | def silent_net():
  class TestNetSpec (line 51) | class TestNetSpec(unittest.TestCase):
    method load_net (line 52) | def load_net(self, net_proto):
    method test_lenet (line 58) | def test_lenet(self):
    method test_zero_tops (line 76) | def test_zero_tops(self):
    method test_type_error (line 83) | def test_type_error(self):

FILE: python/caffe/test/test_python_layer.py
  class SimpleLayer (line 9) | class SimpleLayer(caffe.Layer):
    method setup (line 12) | def setup(self, bottom, top):
    method reshape (line 15) | def reshape(self, bottom, top):
    method forward (line 18) | def forward(self, bottom, top):
    method backward (line 21) | def backward(self, top, propagate_down, bottom):
  class ExceptionLayer (line 25) | class ExceptionLayer(caffe.Layer):
    method setup (line 28) | def setup(self, bottom, top):
  class ParameterLayer (line 31) | class ParameterLayer(caffe.Layer):
    method setup (line 34) | def setup(self, bottom, top):
    method reshape (line 38) | def reshape(self, bottom, top):
    method forward (line 41) | def forward(self, bottom, top):
    method backward (line 44) | def backward(self, top, propagate_down, bottom):
  class PhaseLayer (line 47) | class PhaseLayer(caffe.Layer):
    method setup (line 50) | def setup(self, bottom, top):
    method reshape (line 53) | def reshape(self, bootom, top):
    method forward (line 56) | def forward(self, bottom, top):
  function python_net_file (line 59) | def python_net_file():
  function exception_net_file (line 72) | def exception_net_file():
  function parameter_net_file (line 82) | def parameter_net_file():
  function phase_net_file (line 91) | def phase_net_file():
  class TestPythonLayer (line 102) | class TestPythonLayer(unittest.TestCase):
    method setUp (line 103) | def setUp(self):
    method test_forward (line 108) | def test_forward(self):
    method test_backward (line 115) | def test_backward(self):
    method test_reshape (line 122) | def test_reshape(self):
    method test_exception (line 130) | def test_exception(self):
    method test_parameter (line 135) | def test_parameter(self):
    method test_phase (line 168) | def test_phase(self):

FILE: python/caffe/test/test_python_layer_with_param_str.py
  class SimpleParamLayer (line 9) | class SimpleParamLayer(caffe.Layer):
    method setup (line 12) | def setup(self, bottom, top):
    method reshape (line 18) | def reshape(self, bottom, top):
    method forward (line 21) | def forward(self, bottom, top):
    method backward (line 24) | def backward(self, top, propagate_down, bottom):
  function python_param_net_file (line 28) | def python_param_net_file():
  class TestLayerWithParam (line 43) | class TestLayerWithParam(unittest.TestCase):
    method setUp (line 44) | def setUp(self):
    method test_forward (line 49) | def test_forward(self):
    method test_backward (line 56) | def test_backward(self):

FILE: python/caffe/test/test_solver.py
  class TestSolver (line 11) | class TestSolver(unittest.TestCase):
    method setUp (line 12) | def setUp(self):
    method test_solve (line 39) | def test_solve(self):
    method test_net_memory (line 44) | def test_net_memory(self):
    method test_snapshot (line 59) | def test_snapshot(self):

FILE: python/classify.py
  function main (line 17) | def main(argv):

FILE: python/detect.py
  function main (line 30) | def main(argv):

FILE: python/draw_net.py
  function parse_args (line 13) | def parse_args():
  function main (line 41) | def main():

FILE: python/train.py
  function train (line 10) | def train(
  function time (line 33) | def time(solver, nccl):
  function solve (line 65) | def solve(proto, snapshot, gpus, timing, uid, rank):

FILE: scripts/cpp_lint.py
  function ParseNolintSuppressions (line 468) | def ParseNolintSuppressions(filename, raw_line, linenum, error):
  function ResetNolintSuppressions (line 499) | def ResetNolintSuppressions():
  function IsErrorSuppressedByNolint (line 504) | def IsErrorSuppressedByNolint(category, linenum):
  function Match (line 519) | def Match(pattern, s):
  function ReplaceAll (line 529) | def ReplaceAll(pattern, rep, s):
  function Search (line 547) | def Search(pattern, s):
  class _IncludeState (line 554) | class _IncludeState(dict):
    method __init__ (line 588) | def __init__(self):
    method ResetSection (line 592) | def ResetSection(self):
    method SetLastHeader (line 598) | def SetLastHeader(self, header_path):
    method CanonicalizeAlphabeticalOrder (line 601) | def CanonicalizeAlphabeticalOrder(self, header_path):
    method IsInAlphabeticalOrder (line 616) | def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path):
    method CheckNextIncludeOrder (line 637) | def CheckNextIncludeOrder(self, header_type):
  class _CppLintState (line 691) | class _CppLintState(object):
    method __init__ (line 694) | def __init__(self):
    method SetOutputFormat (line 707) | def SetOutputFormat(self, output_format):
    method SetVerboseLevel (line 711) | def SetVerboseLevel(self, level):
    method SetCountingStyle (line 717) | def SetCountingStyle(self, counting_style):
    method SetFilters (line 721) | def SetFilters(self, filters):
    method ResetErrorCounts (line 746) | def ResetErrorCounts(self):
    method IncrementErrorCount (line 751) | def IncrementErrorCount(self, category):
    method PrintErrorCounts (line 761) | def PrintErrorCounts(self):
  function _OutputFormat (line 771) | def _OutputFormat():
  function _SetOutputFormat (line 776) | def _SetOutputFormat(output_format):
  function _VerboseLevel (line 781) | def _VerboseLevel():
  function _SetVerboseLevel (line 786) | def _SetVerboseLevel(level):
  function _SetCountingStyle (line 791) | def _SetCountingStyle(level):
  function _Filters (line 796) | def _Filters():
  function _SetFilters (line 801) | def _SetFilters(filters):
  class _FunctionState (line 814) | class _FunctionState(object):
    method __init__ (line 820) | def __init__(self):
    method Begin (line 825) | def Begin(self, function_name):
    method Count (line 835) | def Count(self):
    method Check (line 840) | def Check(self, error, filename, linenum):
    method End (line 865) | def End(self):
  class _IncludeError (line 870) | class _IncludeError(Exception):
  class FileInfo (line 875) | class FileInfo:
    method __init__ (line 882) | def __init__(self, filename):
    method FullName (line 885) | def FullName(self):
    method RepositoryName (line 889) | def RepositoryName(self):
    method Split (line 934) | def Split(self):
    method BaseName (line 948) | def BaseName(self):
    method Extension (line 952) | def Extension(self):
    method NoExtension (line 956) | def NoExtension(self):
    method IsSource (line 960) | def IsSource(self):
  function _ShouldPrintError (line 965) | def _ShouldPrintError(category, confidence, linenum):
  function Error (line 992) | def Error(filename, linenum, category, confidence, message):
  function IsCppString (line 1049) | def IsCppString(line):
  function CleanseRawStrings (line 1066) | def CleanseRawStrings(raw_lines):
  function FindNextMultiLineCommentStart (line 1127) | def FindNextMultiLineCommentStart(lines, lineix):
  function FindNextMultiLineCommentEnd (line 1138) | def FindNextMultiLineCommentEnd(lines, lineix):
  function RemoveMultiLineCommentsFromRange (line 1147) | def RemoveMultiLineCommentsFromRange(lines, begin, end):
  function RemoveMultiLineComments (line 1155) | def RemoveMultiLineComments(filename, lines, error):
  function CleanseComments (line 1171) | def CleanseComments(line):
  class CleansedLines (line 1187) | class CleansedLines(object):
    method __init__ (line 1196) | def __init__(self, lines):
    method NumLines (line 1208) | def NumLines(self):
    method _CollapseStrings (line 1213) | def _CollapseStrings(elided):
  function FindEndOfExpressionInLine (line 1234) | def FindEndOfExpressionInLine(line, startpos, depth, startchar, endchar):
  function CloseExpression (line 1258) | def CloseExpression(clean_lines, linenum, pos):
  function FindStartOfExpressionInLine (line 1304) | def FindStartOfExpressionInLine(line, endpos, depth, startchar, endchar):
  function ReverseCloseExpression (line 1331) | def ReverseCloseExpression(clean_lines, linenum, pos):
  function CheckForCopyright (line 1376) | def CheckForCopyright(filename, lines, error):
  function GetHeaderGuardCPPVariable (line 1388) | def GetHeaderGuardCPPVariable(filename):
  function CheckForHeaderGuard (line 1412) | def CheckForHeaderGuard(filename, lines, error):
  function CheckForBadCharacters (line 1487) | def CheckForBadCharacters(filename, lines, error):
  function CheckForNewlineAtEOF (line 1512) | def CheckForNewlineAtEOF(filename, lines, error):
  function CheckForMultilineCommentsAndStrings (line 1530) | def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, ...
  function CheckCaffeAlternatives (line 1576) | def CheckCaffeAlternatives(filename, clean_lines, linenum, error):
  function CheckCaffeDataLayerSetUp (line 1599) | def CheckCaffeDataLayerSetUp(filename, clean_lines, linenum, error):
  function CheckCaffeRandom (line 1644) | def CheckCaffeRandom(filename, clean_lines, linenum, error):
  function CheckPosixThreading (line 1685) | def CheckPosixThreading(filename, clean_lines, linenum, error):
  function CheckVlogArguments (line 1712) | def CheckVlogArguments(filename, clean_lines, linenum, error):
  function CheckInvalidIncrement (line 1737) | def CheckInvalidIncrement(filename, clean_lines, linenum, error):
  class _BlockInfo (line 1759) | class _BlockInfo(object):
    method __init__ (line 1762) | def __init__(self, seen_open_brace):
    method CheckBegin (line 1767) | def CheckBegin(self, filename, clean_lines, linenum, error):
    method CheckEnd (line 1782) | def CheckEnd(self, filename, clean_lines, linenum, error):
  class _ClassInfo (line 1796) | class _ClassInfo(_BlockInfo):
    method __init__ (line 1799) | def __init__(self, name, class_or_struct, clean_lines, linenum):
    method CheckBegin (line 1833) | def CheckBegin(self, filename, clean_lines, linenum, error):
    method CheckEnd (line 1838) | def CheckEnd(self, filename, clean_lines, linenum, error):
  class _NamespaceInfo (line 1852) | class _NamespaceInfo(_BlockInfo):
    method __init__ (line 1855) | def __init__(self, name, linenum):
    method CheckEnd (line 1860) | def CheckEnd(self, filename, clean_lines, linenum, error):
  class _PreprocessorInfo (line 1906) | class _PreprocessorInfo(object):
    method __init__ (line 1909) | def __init__(self, stack_before_if):
  class _NestingState (line 1920) | class _NestingState(object):
    method __init__ (line 1923) | def __init__(self):
    method SeenOpenBrace (line 1935) | def SeenOpenBrace(self):
    method InNamespaceBody (line 1944) | def InNamespaceBody(self):
    method UpdatePreprocessor (line 1952) | def UpdatePreprocessor(self, line):
    method Update (line 2008) | def Update(self, filename, clean_lines, linenum, error):
    method InnermostClass (line 2164) | def InnermostClass(self):
    method CheckCompletedBlocks (line 2176) | def CheckCompletedBlocks(self, filename, error):
  function CheckForNonStandardConstructs (line 2198) | def CheckForNonStandardConstructs(filename, clean_lines, linenum,
  function CheckSpacingForFunctionCall (line 2305) | def CheckSpacingForFunctionCall(filename, line, linenum, error):
  function IsBlankLine (line 2373) | def IsBlankLine(line):
  function CheckForFunctionLengths (line 2388) | def CheckForFunctionLengths(filename, clean_lines, linenum,
  function CheckComment (line 2461) | def CheckComment(comment, filename, linenum, error):
  function CheckAccess (line 2490) | def CheckAccess(filename, clean_lines, linenum, nesting_state, error):
  function FindNextMatchingAngleBracket (line 2521) | def FindNextMatchingAngleBracket(clean_lines, linenum, init_suffix):
  function FindPreviousMatchingAngleBracket (line 2590) | def FindPreviousMatchingAngleBracket(clean_lines, linenum, init_prefix):
  function CheckSpacing (line 2647) | def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):
  function CheckSectionSpacing (line 2995) | def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
  function GetPreviousNonBlankLine (line 3050) | def GetPreviousNonBlankLine(clean_lines, linenum):
  function CheckBraces (line 3073) | def CheckBraces(filename, clean_lines, linenum, error):
  function CheckEmptyBlockBody (line 3247) | def CheckEmptyBlockBody(filename, clean_lines, linenum, error):
  function CheckCheck (line 3282) | def CheckCheck(filename, clean_lines, linenum, error):
  function CheckAltTokens (line 3409) | def CheckAltTokens(filename, clean_lines, linenum, error):
  function GetLineWidth (line 3441) | def GetLineWidth(line):
  function CheckStyle (line 3463) | def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_s...
  function _DropCommonSuffixes (line 3580) | def _DropCommonSuffixes(filename):
  function _IsTestFilename (line 3607) | def _IsTestFilename(filename):
  function _ClassifyInclude (line 3624) | def _ClassifyInclude(fileinfo, include, is_system):
  function CheckIncludeLine (line 3684) | def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):
  function _GetTextInside (line 3756) | def _GetTextInside(text, start_pattern):
  function CheckLanguage (line 3838) | def CheckLanguage(filename, clean_lines, linenum, file_extension,
  function CheckForNonConstReference (line 4138) | def CheckForNonConstReference(filename, clean_lines, linenum,
  function CheckCStyleCast (line 4251) | def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern,
  function FilesBelongToSameModule (line 4403) | def FilesBelongToSameModule(filename_cc, filename_h):
  function UpdateIncludeState (line 4458) | def UpdateIncludeState(filename, include_state, io=codecs):
  function CheckForIncludeWhatYouUse (line 4487) | def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,
  function CheckMakePairUsesDeduction (line 4583) | def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):
  function ProcessLine (line 4604) | def ProcessLine(filename, file_extension, clean_lines, line,
  function ProcessFileData (line 4648) | def ProcessFileData(filename, file_extension, lines, error,
  function ProcessFile (line 4693) | def ProcessFile(filename, vlevel, extra_check_functions=[]):
  function PrintUsage (line 4761) | def PrintUsage(message):
  function PrintCategories (line 4774) | def PrintCategories():
  function ParseArguments (line 4783) | def ParseArguments(args):
  function main (line 4853) | def main():

FILE: scripts/download_model_binary.py
  function reporthook (line 14) | def reporthook(count, block_size, total_size):
  function parse_readme_frontmatter (line 31) | def parse_readme_frontmatter(dirname):
  function valid_dirname (line 42) | def valid_dirname(dirname):
  function model_checks_out (line 63) | def model_checks_out(filename=model_filename, sha1=frontmatter['sha1']):

FILE: scripts/download_prebuilt_dependencies.py
  function model_checks_out (line 24) | def model_checks_out(filename, sha1):

FILE: src/caffe/blob.cpp
  type caffe (line 9) | namespace caffe {
    function Dtype (line 84) | const Dtype* Blob<Dtype>::cpu_data() const {
    function Dtype (line 102) | const Dtype* Blob<Dtype>::gpu_data() const {
    function Dtype (line 120) | const Dtype* Blob<Dtype>::cpu_diff() const {
    function Dtype (line 126) | const Dtype* Blob<Dtype>::gpu_diff() const {
    function Dtype (line 132) | Dtype* Blob<Dtype>::mutable_cpu_data() {
    function Dtype (line 138) | Dtype* Blob<Dtype>::mutable_gpu_data() {
    function Dtype (line 144) | Dtype* Blob<Dtype>::mutable_cpu_diff() {
    function Dtype (line 150) | Dtype* Blob<Dtype>::mutable_gpu_diff() {
    function Dtype (line 216) | Dtype Blob<Dtype>::asum_data() const {
    function Dtype (line 256) | Dtype Blob<Dtype>::asum_diff() const {
    function Dtype (line 296) | Dtype Blob<Dtype>::sumsq_data() const {
    function Dtype (line 338) | Dtype Blob<Dtype>::sumsq_diff() const {
    class Blob<bool> (line 586) | class Blob<bool>
    class Blob<int> (line 587) | class Blob<int>
    class Blob<unsigned int> (line 588) | class Blob<unsigned int>

FILE: src/caffe/common.cpp
  type caffe (line 15) | namespace caffe {
    function Caffe (line 20) | Caffe& Caffe::Get() {
    function cluster_seedgen (line 28) | int64_t cluster_seedgen(void) {
    function GlobalInit (line 48) | void GlobalInit(int* pargc, char*** pargv) {
    class Caffe::RNG::Generator (line 91) | class Caffe::RNG::Generator {
      method Generator (line 93) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 94) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}
      method Generator (line 249) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 250) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}
    class Caffe::RNG::Generator (line 247) | class Caffe::RNG::Generator {
      method Generator (line 93) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 94) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}
      method Generator (line 249) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 250) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}

FILE: src/caffe/data_reader.cpp
  type caffe (line 12) | namespace caffe {
    class DataReader<Datum> (line 135) | class DataReader<Datum>
    class DataReader<AnnotatedDatum> (line 136) | class DataReader<AnnotatedDatum>

FILE: src/caffe/data_transformer.cpp
  type caffe (line 19) | namespace caffe {

FILE: src/caffe/internal_thread.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layer.cpp
  type caffe (line 3) | namespace caffe {

FILE: src/caffe/layer_factory.cpp
  type caffe (line 53) | namespace caffe {
    function string (line 103) | string LayerRegistry<Dtype>::LayerTypeListString() {
    function GetReorgLayer (line 130) | shared_ptr<Layer<Dtype> > GetReorgLayer(const LayerParameter& param) {
    function GetSigmoidCrossEntropyLossLayer (line 136) | shared_ptr<Layer<Dtype> > GetSigmoidCrossEntropyLossLayer(const LayerP...
    function GetAnnotatedDataLayer (line 144) | shared_ptr<Layer<Dtype> > GetAnnotatedDataLayer(const LayerParameter& ...
    function GetBatchNormLayer (line 152) | shared_ptr<Layer<Dtype> > GetBatchNormLayer(const LayerParameter& para...
    function GetBiasLayer (line 160) | shared_ptr<Layer<Dtype> > GetBiasLayer(const LayerParameter& param) {
    function GetConcatLayer (line 168) | shared_ptr<Layer<Dtype> > GetConcatLayer(const LayerParameter& param) {
    function GetDetectionEvaluateLayer (line 176) | shared_ptr<Layer<Dtype> > GetDetectionEvaluateLayer(const LayerParamet...
    function GetFlattenLayer (line 184) | shared_ptr<Layer<Dtype> > GetFlattenLayer(const LayerParameter& param) {
    function GetInputLayer (line 192) | shared_ptr<Layer<Dtype> > GetInputLayer(const LayerParameter& param) {
    function GetYoloDetectionOutputLayer (line 201) | shared_ptr<Layer<Dtype> > GetYoloDetectionOutputLayer(const LayerParam...
    function GetYolov3DetectionOutputLayer (line 208) | shared_ptr<Layer<Dtype> > GetYolov3DetectionOutputLayer(const LayerPar...
    function GetRegionLossLayer (line 216) | shared_ptr<Layer<Dtype> > GetRegionLossLayer(const LayerParameter& par...
    function GetYolov3Layer (line 224) | shared_ptr<Layer<Dtype> > GetYolov3Layer(const LayerParameter& param) {
    function GetReshapeLayer (line 232) | shared_ptr<Layer<Dtype> > GetReshapeLayer(const LayerParameter& param) {
    function GetScaleLayer (line 240) | shared_ptr<Layer<Dtype> > GetScaleLayer(const LayerParameter& param) {
    function GetSoftmaxWithLossLayer (line 248) | shared_ptr<Layer<Dtype> > GetSoftmaxWithLossLayer(const LayerParameter...
    function GetSmoothL1LossLayer (line 256) | shared_ptr<Layer<Dtype> > GetSmoothL1LossLayer(const LayerParameter& p...
    function GetNormalizeLayer (line 266) | shared_ptr<Layer<Dtype> > GetNormalizeLayer(const LayerParameter& para...
    function GetConvolutionLayer (line 276) | shared_ptr<Layer<Dtype> > GetConvolutionLayer(
    function GetDepthwiseConvolutionLayer (line 317) | shared_ptr<Layer<Dtype> > GetDepthwiseConvolutionLayer(
    function GetPoolingLayer (line 358) | shared_ptr<Layer<Dtype> > GetPoolingLayer(const LayerParameter& param) {
    function GetLRNLayer (line 396) | shared_ptr<Layer<Dtype> > GetLRNLayer(const LayerParameter& param) {
    function GetReLU6Layer (line 434) | shared_ptr<Layer<Dtype> > GetReLU6Layer(const LayerParameter& param) {
    function GetReLULayer (line 458) | shared_ptr<Layer<Dtype> > GetReLULayer(const LayerParameter& param) {
    function GetSigmoidLayer (line 482) | shared_ptr<Layer<Dtype> > GetSigmoidLayer(const LayerParameter& param) {
    function GetSoftmaxLayer (line 506) | shared_ptr<Layer<Dtype> > GetSoftmaxLayer(const LayerParameter& param) {
    function GetTanHLayer (line 530) | shared_ptr<Layer<Dtype> > GetTanHLayer(const LayerParameter& param) {
    function GetPythonLayer (line 554) | shared_ptr<Layer<Dtype> > GetPythonLayer(const LayerParameter& param) {

FILE: src/caffe/layers/absval_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/accuracy_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/annotated_data_layer.cpp
  type caffe (line 16) | namespace caffe {

FILE: src/caffe/layers/argmax_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/base_conv_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/base_data_layer.cpp
  type caffe (line 12) | namespace caffe {

FILE: src/caffe/layers/batch_norm_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/batch_reindex_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/bias_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/bnll_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/concat_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/contrastive_loss_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/conv_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/crop_layer.cpp
  type caffe (line 13) | namespace caffe {

FILE: src/caffe/layers/cudnn_conv_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/cudnn_lcn_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/cudnn_lrn_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/cudnn_pooling_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/cudnn_relu_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/cudnn_sigmoid_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/cudnn_softmax_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/cudnn_tanh_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/data_layer.cpp
  type caffe (line 12) | namespace caffe {

FILE: src/caffe/layers/deconv_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/depthwise_conv_layer.cpp
  type caffe (line 4) | namespace caffe {

FILE: src/caffe/layers/detection_evaluate_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/dropout_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/dummy_data_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/eltwise_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/elu_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/embed_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/euclidean_loss_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/exp_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/filter_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/flatten_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/hdf5_data_layer.cpp
  type caffe (line 20) | namespace caffe {

FILE: src/caffe/layers/hdf5_output_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/hinge_loss_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/im2col_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/image_data_layer.cpp
  type caffe (line 18) | namespace caffe {

FILE: src/caffe/layers/infogain_loss_layer.cpp
  type caffe (line 9) | namespace caffe {
    function Dtype (line 85) | Dtype InfogainLossLayer<Dtype>::get_normalizer(

FILE: src/caffe/layers/inner_product_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/input_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/loss_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/lrn_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/lstm_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/lstm_unit_layer.cpp
  type caffe (line 8) | namespace caffe {
    function Dtype (line 11) | inline Dtype sigmoid(Dtype x) {
    function Dtype (line 16) | inline Dtype tanh(Dtype x) {

FILE: src/caffe/layers/memory_data_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/multinomial_logistic_loss_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/mvn_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/neuron_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/normalize_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/parameter_layer.cpp
  type caffe (line 3) | namespace caffe {

FILE: src/caffe/layers/pooling_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/power_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/prelu_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/recurrent_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/reduction_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/region_loss_layer.cpp
  type caffe (line 25) | namespace caffe {
    function Dtype (line 27) | Dtype softmax_region(Dtype* input, int classes, int stride)
    function Dtype (line 47) | Dtype overlap(Dtype x1, Dtype w1, Dtype x2, Dtype w2)
    function Dtype (line 58) | Dtype box_intersection(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 67) | Dtype box_union(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 74) | Dtype box_iou(vector<Dtype> a, vector<Dtype> b)
    function get_region_box (line 81) | void get_region_box(vector<Dtype> &b, Dtype* x, vector<Dtype> biases, ...
    function Dtype (line 90) | Dtype delta_region_box(vector<Dtype> truth, Dtype* x, vector<Dtype> bi...
    function delta_region_class (line 113) | void delta_region_class(Dtype* input_data, Dtype* &diff, int index, in...

FILE: src/caffe/layers/relu6_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/relu_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/reorg_layer.cpp
  type caffe (line 4) | namespace caffe {

FILE: src/caffe/layers/reshape_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/rnn_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/scale_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/sigmoid_cross_entropy_loss_layer.cpp
  type caffe (line 7) | namespace caffe {
    function Dtype (line 49) | Dtype SigmoidCrossEntropyLossLayer<Dtype>::get_normalizer(

FILE: src/caffe/layers/sigmoid_layer.cpp
  type caffe (line 6) | namespace caffe {
    function Dtype (line 9) | inline Dtype sigmoid(Dtype x) {

FILE: src/caffe/layers/silence_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/slice_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/smooth_L1_loss_layer.cpp
  type caffe (line 14) | namespace caffe {

FILE: src/caffe/layers/softmax_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/softmax_loss_layer.cpp
  type caffe (line 8) | namespace caffe {
    function Dtype (line 59) | Dtype SoftmaxWithLossLayer<Dtype>::get_normalizer(

FILE: src/caffe/layers/split_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/spp_layer.cpp
  type caffe (line 11) | namespace caffe {
    function LayerParameter (line 17) | LayerParameter SPPLayer<Dtype>::GetPoolingParam(const int pyramid_level,

FILE: src/caffe/layers/tanh_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/threshold_layer.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/layers/tile_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/window_data_layer.cpp
  type caffe (line 28) | namespace caffe {

FILE: src/caffe/layers/yolo_detection_output_layer.cpp
  type caffe (line 16) | namespace caffe {
    function Dtype (line 18) | Dtype overlap(Dtype x1, Dtype w1, Dtype x2, Dtype w2)
    function Dtype (line 29) | Dtype box_intersection(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 38) | Dtype box_union(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 45) | Dtype box_iou(vector<Dtype> a, vector<Dtype> b)
    function setNormalizedBBox (line 50) | void setNormalizedBBox(NormalizedBBox& bbox, Dtype x, Dtype y, Dtype w...
    function ApplyNms (line 77) | void ApplyNms(vector< PredictionResult<Dtype> >& boxes, vector<int>& i...
    function class_index_and_score (line 120) | void class_index_and_score(Dtype* input, int classes, PredictionResult...
    function get_region_box (line 151) | void get_region_box(Dtype* x, PredictionResult<Dtype>& predict, vector...
    function BoxSortDecendScore (line 210) | bool BoxSortDecendScore(const PredictionResult<Dtype>& box1, const Pre...

FILE: src/caffe/layers/yolov3_detection_output_layer.cpp
  type caffe (line 23) | namespace caffe {
    function Dtype (line 25) | inline Dtype sigmoid(Dtype x)
    class PredictionResult (line 30) | class PredictionResult {
    function Dtype (line 42) | Dtype overlap(Dtype x1, Dtype w1, Dtype x2, Dtype w2)
    function Dtype (line 53) | Dtype box_intersection(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 62) | Dtype box_union(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 69) | Dtype box_iou(vector<Dtype> a, vector<Dtype> b)
    function setNormalizedBBox (line 74) | void setNormalizedBBox(NormalizedBBox& bbox, Dtype x, Dtype y, Dtype w...
    function ApplyNms (line 101) | void ApplyNms(vector< PredictionResult<Dtype> >& boxes, vector<int>& i...
    function class_index_and_score (line 144) | void class_index_and_score(Dtype* input, int classes, PredictionResult...
    function get_region_box2 (line 175) | void get_region_box2(vector<Dtype> &b, Dtype* x, vector<Dtype> biases,...
    function BoxSortDecendScore (line 227) | bool BoxSortDecendScore(const PredictionResult<Dtype>& box1, const Pre...

FILE: src/caffe/layers/yolov3_layer.cpp
  type caffe (line 30) | namespace caffe {
    function Dtype (line 35) | Dtype overlap(Dtype x1, Dtype w1, Dtype x2, Dtype w2)
    function Dtype (line 46) | Dtype box_intersection(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 55) | Dtype box_union(vector<Dtype> a, vector<Dtype> b)
    function Dtype (line 62) | Dtype box_iou(vector<Dtype> a, vector<Dtype> b)
    function delta_region_class_v3 (line 67) | void delta_region_class_v3(Dtype* input_data, Dtype* &diff, int index,...
    function get_region_box (line 84) | void get_region_box(vector<Dtype> &b, Dtype* x, vector<Dtype> biases, ...
    function Dtype (line 93) | Dtype delta_region_box(vector<Dtype> truth, Dtype* x, vector<Dtype> bi...
    function int_index (line 158) | int int_index(vector<Dtype> a, int val, int n)

FILE: src/caffe/net.cpp
  type caffe (line 20) | namespace caffe {
    function Dtype (line 516) | Dtype Net<Dtype>::ForwardFromTo(int start, int end) {
    function Dtype (line 535) | Dtype Net<Dtype>::ForwardFrom(int start) {
    function Dtype (line 540) | Dtype Net<Dtype>::ForwardTo(int end) {

FILE: src/caffe/parallel.cpp
  type caffe (line 14) | namespace caffe {
    type Op (line 16) | enum Op {
    function apply_buffers (line 25) | static void apply_buffers(const vector<Blob<Dtype>*>& blobs,
    function total_size (line 59) | static size_t total_size(const vector<Blob<Dtype>*>& params) {
    function getDevice (line 110) | static int getDevice() {
    function string (line 179) | string NCCL<Dtype>::new_uid() {
    class Worker (line 259) | class Worker : public InternalThread {
      method Worker (line 261) | explicit Worker(shared_ptr<Solver<Dtype> > rank0, int device,
      method InternalThreadEntry (line 270) | void InternalThreadEntry() {

FILE: src/caffe/solver.cpp
  type caffe (line 16) | namespace caffe {
    function LoadNetWeights (line 81) | void LoadNetWeights(shared_ptr<Net<Dtype> > net,
    function string (line 598) | string Solver<Dtype>::SnapshotFilename(const string extension) {
    function string (line 604) | string Solver<Dtype>::SnapshotToBinaryProto() {
    function string (line 614) | string Solver<Dtype>::SnapshotToHDF5() {

FILE: src/caffe/solver_factory.cpp
  type caffe (line 8) | namespace caffe {
    function string (line 54) | string SolverRegistry<Dtype>::SolverTypeListString() {

FILE: src/caffe/solvers/adadelta_solver.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/solvers/adagrad_solver.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/solvers/adam_solver.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/solvers/nesterov_solver.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/solvers/rmsprop_solver.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/solvers/sgd_solver.cpp
  type caffe (line 9) | namespace caffe {
    function Dtype (line 27) | Dtype SGDSolver<Dtype>::GetLearningRate() {

FILE: src/caffe/syncedmem.cpp
  type caffe (line 5) | namespace caffe {

FILE: src/caffe/test/test_accuracy_layer.cpp
  type caffe (line 14) | namespace caffe {
    class AccuracyLayerTest (line 17) | class AccuracyLayerTest : public CPUDeviceTest<Dtype> {
      method AccuracyLayerTest (line 19) | AccuracyLayerTest()
      method FillBottoms (line 40) | virtual void FillBottoms() {
    function TYPED_TEST (line 74) | TYPED_TEST(AccuracyLayerTest, TestSetup) {
    function TYPED_TEST (line 84) | TYPED_TEST(AccuracyLayerTest, TestSetupTopK) {
    function TYPED_TEST (line 97) | TYPED_TEST(AccuracyLayerTest, TestSetupOutputPerClass) {
    function TYPED_TEST (line 111) | TYPED_TEST(AccuracyLayerTest, TestForwardCPU) {
    function TYPED_TEST (line 137) | TYPED_TEST(AccuracyLayerTest, TestForwardWithSpatialAxes) {
    function TYPED_TEST (line 180) | TYPED_TEST(AccuracyLayerTest, TestForwardIgnoreLabel) {
    function TYPED_TEST (line 218) | TYPED_TEST(AccuracyLayerTest, TestForwardCPUTopK) {
    function TYPED_TEST (line 249) | TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClass) {
    function TYPED_TEST (line 287) | TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClassWithIgnoreLabel) {

FILE: src/caffe/test/test_annotated_data_layer.cpp
  type caffe (line 19) | namespace caffe {
    function OneBBoxNum (line 27) | int OneBBoxNum(int n) {
    function BBoxNum (line 35) | int BBoxNum(int n) {
    class AnnotatedDataLayerTest (line 46) | class AnnotatedDataLayerTest : public MultiDeviceTest<TypeParam> {
      method AnnotatedDataLayerTest (line 50) | AnnotatedDataLayerTest()
      method SetUp (line 61) | virtual void SetUp() {
      method Fill (line 80) | void Fill(DataParameter_DB backend, bool unique_pixel, bool unique_a...
      method TestRead (line 137) | void TestRead() {
      method TestReshape (line 222) | void TestReshape(DataParameter_DB backend, bool unique_pixel,
      method TestReadCrop (line 370) | void TestReadCrop(Phase phase) {
      method TestReadCropTrainSequenceSeeded (line 427) | void TestReadCropTrainSequenceSeeded() {
      method TestReadCropTrainSequenceUnseeded (line 482) | void TestReadCropTrainSequenceUnseeded() {
    function TYPED_TEST (line 568) | TYPED_TEST(AnnotatedDataLayerTest, TestReadLevelDB) {
    function TYPED_TEST (line 587) | TYPED_TEST(AnnotatedDataLayerTest, TestReshapeLevelDB) {
    function TYPED_TEST (line 605) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTrainLevelDB) {
    function TYPED_TEST (line 617) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTrainSequenceSeededLeve...
    function TYPED_TEST (line 629) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTrainSequenceUnseededLe...
    function TYPED_TEST (line 639) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTestLevelDB) {
    function TYPED_TEST (line 651) | TYPED_TEST(AnnotatedDataLayerTest, TestReadLMDB) {
    function TYPED_TEST (line 670) | TYPED_TEST(AnnotatedDataLayerTest, TestReshapeLMDB) {
    function TYPED_TEST (line 688) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTrainLMDB) {
    function TYPED_TEST (line 700) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTrainSequenceSeededLMDB) {
    function TYPED_TEST (line 712) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTrainSequenceUnseededLM...
    function TYPED_TEST (line 722) | TYPED_TEST(AnnotatedDataLayerTest, TestReadCropTestLMDB) {

FILE: src/caffe/test/test_argmax_layer.cpp
  type caffe (line 13) | namespace caffe {
    class ArgMaxLayerTest (line 16) | class ArgMaxLayerTest : public CPUDeviceTest<Dtype> {
      method ArgMaxLayerTest (line 18) | ArgMaxLayerTest()
    function TYPED_TEST (line 40) | TYPED_TEST(ArgMaxLayerTest, TestSetup) {
    function TYPED_TEST (line 48) | TYPED_TEST(ArgMaxLayerTest, TestSetupMaxVal) {
    function TYPED_TEST (line 58) | TYPED_TEST(ArgMaxLayerTest, TestSetupAxis) {
    function TYPED_TEST (line 70) | TYPED_TEST(ArgMaxLayerTest, TestSetupAxisNegativeIndexing) {
    function TYPED_TEST (line 82) | TYPED_TEST(ArgMaxLayerTest, TestSetupAxisMaxVal) {
    function TYPED_TEST (line 95) | TYPED_TEST(ArgMaxLayerTest, TestCPU) {
    function TYPED_TEST (line 118) | TYPED_TEST(ArgMaxLayerTest, TestCPUMaxVal) {
    function TYPED_TEST (line 144) | TYPED_TEST(ArgMaxLayerTest, TestCPUTopK) {
    function TYPED_TEST (line 174) | TYPED_TEST(ArgMaxLayerTest, TestCPUMaxValTopK) {
    function TYPED_TEST (line 206) | TYPED_TEST(ArgMaxLayerTest, TestCPUAxis) {
    function TYPED_TEST (line 232) | TYPED_TEST(ArgMaxLayerTest, TestCPUAxisTopK) {
    function TYPED_TEST (line 265) | TYPED_TEST(ArgMaxLayerTest, TestCPUAxisMaxValTopK) {

FILE: src/caffe/test/test_batch_norm_layer.cpp
  type caffe (line 18) | namespace caffe {
    class BatchNormLayerTest (line 21) | class BatchNormLayerTest : public MultiDeviceTest<TypeParam> {
      method BatchNormLayerTest (line 24) | BatchNormLayerTest()
    function TYPED_TEST (line 43) | TYPED_TEST(BatchNormLayerTest, TestForward) {
    function TYPED_TEST (line 79) | TYPED_TEST(BatchNormLayerTest, TestForwardInplace) {
    function TYPED_TEST (line 123) | TYPED_TEST(BatchNormLayerTest, TestGradient) {

FILE: src/caffe/test/test_batch_reindex_layer.cpp
  type caffe (line 13) | namespace caffe {
    class BatchReindexLayerTest (line 16) | class BatchReindexLayerTest : public MultiDeviceTest<TypeParam> {
      method BatchReindexLayerTest (line 20) | BatchReindexLayerTest()
      method SetUp (line 25) | virtual void SetUp() {
      method TestForward (line 61) | void TestForward() {
    function TYPED_TEST (line 105) | TYPED_TEST(BatchReindexLayerTest, TestForward) {
    function TYPED_TEST (line 109) | TYPED_TEST(BatchReindexLayerTest, TestGradient) {

FILE: src/caffe/test/test_bbox_util.cpp
  type caffe (line 12) | namespace caffe {
    function FillBBoxes (line 16) | void FillBBoxes(vector<NormalizedBBox>* gt_bboxes,
    class BBoxUtilTest (line 88) | class BBoxUtilTest : public MultiDeviceTest<TypeParam> {
    class CPUBBoxUtilTest (line 92) | class CPUBBoxUtilTest : public BBoxUtilTest<CPUDevice<float> > {
    function TEST_F (line 95) | TEST_F(CPUBBoxUtilTest, TestIntersectBBox) {
    function TEST_F (line 139) | TEST_F(CPUBBoxUtilTest, TestBBoxSize) {
    function TEST_F (line 168) | TEST_F(CPUBBoxUtilTest, TestScaleBBox) {
    function TEST_F (line 196) | TEST_F(CPUBBoxUtilTest, TestClipBBox) {
    function TEST_F (line 223) | TEST_F(CPUBBoxUtilTest, TestOutputBBox) {
    function TEST_F (line 283) | TEST_F(CPUBBoxUtilTest, TestJaccardOverlap) {
    function TEST_F (line 318) | TEST_F(CPUBBoxUtilTest, TestEncodeBBoxCorner) {
    function TEST_F (line 352) | TEST_F(CPUBBoxUtilTest, TestEncodeBBoxCenterSize) {
    function TEST_F (line 391) | TEST_F(CPUBBoxUtilTest, TestDecodeBBoxCorner) {
    function TEST_F (line 425) | TEST_F(CPUBBoxUtilTest, TestDecodeBBoxCenterSize) {
    function TEST_F (line 467) | TEST_F(CPUBBoxUtilTest, TestDecodeBBoxesCorner) {
    function TEST_F (line 516) | TEST_F(CPUBBoxUtilTest, TestDecodeBBoxesCenterSize) {
    function TEST_F (line 577) | TEST_F(CPUBBoxUtilTest, TestMatchBBoxLableOneBipartite) {
    function TEST_F (line 608) | TEST_F(CPUBBoxUtilTest, TestMatchBBoxLableAllBipartite) {
    function TEST_F (line 643) | TEST_F(CPUBBoxUtilTest, TestMatchBBoxLableOnePerPrediction) {
    function TEST_F (line 674) | TEST_F(CPUBBoxUtilTest, TestMatchBBoxLableAllPerPrediction) {
    function TEST_F (line 707) | TEST_F(CPUBBoxUtilTest, TestMatchBBoxLableAllPerPredictionEx) {
    function TEST_F (line 740) | TEST_F(CPUBBoxUtilTest, TestGetGroundTruth) {
    function TEST_F (line 814) | TEST_F(CPUBBoxUtilTest, TestGetGroundTruthLabelBBox) {
    function TEST_F (line 888) | TEST_F(CPUBBoxUtilTest, TestGetLocPredictionsShared) {
    function TEST_F (line 930) | TEST_F(CPUBBoxUtilTest, TestGetLocPredictionsUnShared) {
    function TEST_F (line 978) | TEST_F(CPUBBoxUtilTest, TestGetConfidenceScores) {
    function TEST_F (line 1015) | TEST_F(CPUBBoxUtilTest, TestComputeConfLoss) {
    function TEST_F (line 1084) | TEST_F(CPUBBoxUtilTest, TestComputeConfLossMatch) {
    function TEST_F (line 1173) | TEST_F(CPUBBoxUtilTest, TestGetPriorBBoxes) {
    function TEST_F (line 1208) | TEST_F(CPUBBoxUtilTest, TestGetDetectionResults) {
    function TEST_F (line 1276) | TEST_F(CPUBBoxUtilTest, TestApplyNMS) {
    function TEST_F (line 1354) | TEST_F(CPUBBoxUtilTest, TestApplyNMSFast) {
    function TEST_F (line 1422) | TEST_F(CPUBBoxUtilTest, TestCumSum) {
    function TEST_F (line 1438) | TEST_F(CPUBBoxUtilTest, TestComputeAP) {
    function FillBBoxes (line 1559) | void FillBBoxes(Dtype* gt_bboxes, Dtype* pred_bboxes) {
    class GPUBBoxUtilTest (line 1563) | class GPUBBoxUtilTest : public BBoxUtilTest<GPUDevice<Dtype> > {
    function TYPED_TEST (line 1568) | TYPED_TEST(GPUBBoxUtilTest, TestBBoxSize) {
    function TYPED_TEST (line 1592) | TYPED_TEST(GPUBBoxUtilTest, TestJaccardOverlap) {
    function TYPED_TEST (line 1629) | TYPED_TEST(GPUBBoxUtilTest, TestDecodeBBoxesCorner) {
    function TYPED_TEST (line 1681) | TYPED_TEST(GPUBBoxUtilTest, TestDecodeBBoxesCornerTwoClasses) {
    function TYPED_TEST (line 1747) | TYPED_TEST(GPUBBoxUtilTest, TestDecodeBBoxesCornerTwoClassesNegClass0) {
    function TYPED_TEST (line 1825) | TYPED_TEST(GPUBBoxUtilTest, TestDecodeBBoxesCenterSize) {
    function TYPED_TEST (line 1883) | TYPED_TEST(GPUBBoxUtilTest, TestComputeOverlapped) {
    function TYPED_TEST (line 1937) | TYPED_TEST(GPUBBoxUtilTest, TestComputeOverlappedMultiClass) {
    function TYPED_TEST (line 2031) | TYPED_TEST(GPUBBoxUtilTest, TestSoftMaxGPU) {
    function TYPED_TEST (line 2062) | TYPED_TEST(GPUBBoxUtilTest, TestComputeConfLossMatchGPU) {

FILE: src/caffe/test/test_benchmark.cpp
  type caffe (line 10) | namespace caffe {
    class BenchmarkTest (line 15) | class BenchmarkTest : public MultiDeviceTest<TypeParam> {}
    function TYPED_TEST (line 19) | TYPED_TEST(BenchmarkTest, TestTimerConstructor) {
    function TYPED_TEST (line 26) | TYPED_TEST(BenchmarkTest, TestTimerStart) {
    function TYPED_TEST (line 43) | TYPED_TEST(BenchmarkTest, TestTimerStop) {
    function TYPED_TEST (line 60) | TYPED_TEST(BenchmarkTest, TestTimerMilliSeconds) {
    function TYPED_TEST (line 75) | TYPED_TEST(BenchmarkTest, TestTimerSeconds) {

FILE: src/caffe/test/test_bias_layer.cpp
  type caffe (line 14) | namespace caffe {
    class BiasLayerTest (line 17) | class BiasLayerTest : public MultiDeviceTest<TypeParam> {
      method BiasLayerTest (line 21) | BiasLayerTest()
    function TYPED_TEST (line 72) | TYPED_TEST(BiasLayerTest, TestForwardEltwise) {
    function TYPED_TEST (line 90) | TYPED_TEST(BiasLayerTest, TestForwardEltwiseInPlace) {
    function TYPED_TEST (line 110) | TYPED_TEST(BiasLayerTest, TestBackwardEltwiseInPlace) {
    function TYPED_TEST (line 156) | TYPED_TEST(BiasLayerTest, TestForwardEltwiseWithParam) {
    function TYPED_TEST (line 176) | TYPED_TEST(BiasLayerTest, TestForwardBroadcastBegin) {
    function TYPED_TEST (line 199) | TYPED_TEST(BiasLayerTest, TestForwardBroadcastMiddle) {
    function TYPED_TEST (line 222) | TYPED_TEST(BiasLayerTest, TestForwardBroadcastMiddleInPlace) {
    function TYPED_TEST (line 247) | TYPED_TEST(BiasLayerTest, TestBackwardBroadcastMiddleInPlace) {
    function TYPED_TEST (line 293) | TYPED_TEST(BiasLayerTest, TestForwardBroadcastMiddleWithParam) {
    function TYPED_TEST (line 317) | TYPED_TEST(BiasLayerTest, TestForwardBroadcastEnd) {
    function TYPED_TEST (line 340) | TYPED_TEST(BiasLayerTest, TestForwardBias) {
    function TYPED_TEST (line 357) | TYPED_TEST(BiasLayerTest, TestForwardBiasAxis2) {
    function TYPED_TEST (line 375) | TYPED_TEST(BiasLayerTest, TestGradientEltwise) {
    function TYPED_TEST (line 386) | TYPED_TEST(BiasLayerTest, TestGradientEltwiseWithParam) {
    function TYPED_TEST (line 399) | TYPED_TEST(BiasLayerTest, TestGradientBroadcastBegin) {
    function TYPED_TEST (line 410) | TYPED_TEST(BiasLayerTest, TestGradientBroadcastMiddle) {
    function TYPED_TEST (line 421) | TYPED_TEST(BiasLayerTest, TestGradientBroadcastMiddleWithParam) {
    function TYPED_TEST (line 435) | TYPED_TEST(BiasLayerTest, TestGradientBroadcastEnd) {
    function TYPED_TEST (line 446) | TYPED_TEST(BiasLayerTest, TestGradientBias) {
    function TYPED_TEST (line 456) | TYPED_TEST(BiasLayerTest, TestGradientBiasAxis2) {

FILE: src/caffe/test/test_blob.cpp
  type caffe (line 11) | namespace caffe {
    class BlobSimpleTest (line 14) | class BlobSimpleTest : public ::testing::Test {
      method BlobSimpleTest (line 16) | BlobSimpleTest()
    function TYPED_TEST (line 26) | TYPED_TEST(BlobSimpleTest, TestInitialization) {
    function TYPED_TEST (line 38) | TYPED_TEST(BlobSimpleTest, TestPointersCPUGPU) {
    function TYPED_TEST (line 45) | TYPED_TEST(BlobSimpleTest, TestReshape) {
    function TYPED_TEST (line 54) | TYPED_TEST(BlobSimpleTest, TestReshapeZero) {
    function TYPED_TEST (line 62) | TYPED_TEST(BlobSimpleTest, TestLegacyBlobProtoShapeEquals) {
    class BlobMathTest (line 116) | class BlobMathTest : public MultiDeviceTest<TypeParam> {
      method BlobMathTest (line 119) | BlobMathTest()
    function TYPED_TEST (line 130) | TYPED_TEST(BlobMathTest, TestSumOfSquares) {
    function TYPED_TEST (line 185) | TYPED_TEST(BlobMathTest, TestAsum) {
    function TYPED_TEST (line 239) | TYPED_TEST(BlobMathTest, TestScaleData) {

FILE: src/caffe/test/test_caffe_main.cpp
  type caffe (line 4) | namespace caffe {
  function main (line 14) | int main(int argc, char** argv) {

FILE: src/caffe/test/test_common.cpp
  type caffe (line 9) | namespace caffe {
    class CommonTest (line 11) | class CommonTest : public ::testing::Test {}
    function TEST_F (line 15) | TEST_F(CommonTest, TestCublasHandlerGPU) {
    function TEST_F (line 23) | TEST_F(CommonTest, TestBrewMode) {
    function TEST_F (line 30) | TEST_F(CommonTest, TestRandSeedCPU) {
    function TEST_F (line 47) | TEST_F(CommonTest, TestRandSeedGPU) {

FILE: src/caffe/test/test_concat_layer.cpp
  type caffe (line 13) | namespace caffe {
    class ConcatLayerTest (line 16) | class ConcatLayerTest : public MultiDeviceTest<TypeParam> {
      method ConcatLayerTest (line 20) | ConcatLayerTest()
      method SetUp (line 25) | virtual void SetUp() {
    function TYPED_TEST (line 60) | TYPED_TEST(ConcatLayerTest, TestSetupNum) {
    function TYPED_TEST (line 73) | TYPED_TEST(ConcatLayerTest, TestSetupChannels) {
    function TYPED_TEST (line 85) | TYPED_TEST(ConcatLayerTest, TestSetupChannelsNegativeIndexing) {
    function TYPED_TEST (line 101) | TYPED_TEST(ConcatLayerTest, TestForwardTrivial) {
    function TYPED_TEST (line 114) | TYPED_TEST(ConcatLayerTest, TestForwardNum) {
    function TYPED_TEST (line 143) | TYPED_TEST(ConcatLayerTest, TestForwardChannels) {
    function TYPED_TEST (line 169) | TYPED_TEST(ConcatLayerTest, TestGradientTrivial) {
    function TYPED_TEST (line 179) | TYPED_TEST(ConcatLayerTest, TestGradientNum) {
    function TYPED_TEST (line 189) | TYPED_TEST(ConcatLayerTest, TestGradientChannels) {
    function TYPED_TEST (line 198) | TYPED_TEST(ConcatLayerTest, TestGradientChannelsBottomOneOnly) {

FILE: src/caffe/test/test_contrastive_loss_layer.cpp
  type caffe (line 15) | namespace caffe {
    class ContrastiveLossLayerTest (line 18) | class ContrastiveLossLayerTest : public MultiDeviceTest<TypeParam> {
      method ContrastiveLossLayerTest (line 22) | ContrastiveLossLayerTest()
    function TYPED_TEST (line 59) | TYPED_TEST(ContrastiveLossLayerTest, TestForward) {
    function TYPED_TEST (line 88) | TYPED_TEST(ContrastiveLossLayerTest, TestGradient) {
    function TYPED_TEST (line 101) | TYPED_TEST(ContrastiveLossLayerTest, TestForwardLegacy) {
    function TYPED_TEST (line 130) | TYPED_TEST(ContrastiveLossLayerTest, TestGradientLegacy) {

FILE: src/caffe/test/test_convolution_layer.cpp
  type caffe (line 17) | namespace caffe {
    function caffe_conv (line 22) | void caffe_conv(const Blob<Dtype>* in, ConvolutionParameter* conv_param,
    class ConvolutionLayerTest (line 151) | class ConvolutionLayerTest : public MultiDeviceTest<TypeParam> {
      method ConvolutionLayerTest (line 155) | ConvolutionLayerTest()
      method SetUp (line 160) | virtual void SetUp() {
    function TYPED_TEST (line 195) | TYPED_TEST(ConvolutionLayerTest, TestSetup) {
    function TYPED_TEST (line 231) | TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolution) {
    function TYPED_TEST (line 267) | TYPED_TEST(ConvolutionLayerTest, TestDilatedConvolution) {
    function TYPED_TEST (line 311) | TYPED_TEST(ConvolutionLayerTest, Test0DConvolution) {
    function TYPED_TEST (line 349) | TYPED_TEST(ConvolutionLayerTest, TestSimple3DConvolution) {
    function TYPED_TEST (line 396) | TYPED_TEST(ConvolutionLayerTest, TestDilated3DConvolution) {
    function TYPED_TEST (line 443) | TYPED_TEST(ConvolutionLayerTest, Test1x1Convolution) {
    function TYPED_TEST (line 470) | TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolutionGroup) {
    function TYPED_TEST (line 498) | TYPED_TEST(ConvolutionLayerTest, TestSobelConvolution) {
    function TYPED_TEST (line 591) | TYPED_TEST(ConvolutionLayerTest, TestNDAgainst2D) {
    function TYPED_TEST (line 709) | TYPED_TEST(ConvolutionLayerTest, TestGradient) {
    function TYPED_TEST (line 727) | TYPED_TEST(ConvolutionLayerTest, TestDilatedGradient) {
    function TYPED_TEST (line 751) | TYPED_TEST(ConvolutionLayerTest, TestGradient3D) {
    function TYPED_TEST (line 779) | TYPED_TEST(ConvolutionLayerTest, Test1x1Gradient) {
    function TYPED_TEST (line 797) | TYPED_TEST(ConvolutionLayerTest, TestGradientGroup) {
    class CuDNNConvolutionLayerTest (line 817) | class CuDNNConvolutionLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNConvolutionLayerTest (line 819) | CuDNNConvolutionLayerTest()
      method SetUp (line 824) | virtual void SetUp() {
    function TYPED_TEST (line 859) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSetupCuDNN) {
    function TYPED_TEST (line 896) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSimpleConvolutionCuDNN) {
    function TYPED_TEST (line 931) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSimpleConvolutionGroupCuDNN) {
    function TYPED_TEST (line 958) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSobelConvolutionCuDNN) {
    function TYPED_TEST (line 1051) | TYPED_TEST(CuDNNConvolutionLayerTest, TestGradientCuDNN) {
    function TYPED_TEST (line 1068) | TYPED_TEST(CuDNNConvolutionLayerTest, TestGradientGroupCuDNN) {

FILE: src/caffe/test/test_crop_layer.cpp
  type caffe (line 13) | namespace caffe {
    class CropLayerTest (line 16) | class CropLayerTest : public MultiDeviceTest<TypeParam> {
      method CropLayerTest (line 20) | CropLayerTest()
      method SetUp (line 24) | virtual void SetUp() {
    function TYPED_TEST (line 51) | TYPED_TEST(CropLayerTest, TestSetupShapeAll) {
    function TYPED_TEST (line 63) | TYPED_TEST(CropLayerTest, TestSetupShapeDefault) {
    function TYPED_TEST (line 78) | TYPED_TEST(CropLayerTest, TestSetupShapeNegativeIndexing) {
    function TYPED_TEST (line 94) | TYPED_TEST(CropLayerTest, TestDimensionsCheck) {
    function TYPED_TEST (line 112) | TYPED_TEST(CropLayerTest, TestCropAll) {
    function TYPED_TEST (line 136) | TYPED_TEST(CropLayerTest, TestCropAllOffset) {
    function TYPED_TEST (line 164) | TYPED_TEST(CropLayerTest, TestCropHW) {
    function TYPED_TEST (line 190) | TYPED_TEST(CropLayerTest, TestCrop5D) {
    function TYPED_TEST (line 241) | TYPED_TEST(CropLayerTest, TestCropAllGradient) {
    function TYPED_TEST (line 251) | TYPED_TEST(CropLayerTest, TestCropHWGradient) {
    function TYPED_TEST (line 263) | TYPED_TEST(CropLayerTest, TestCrop5DGradient) {

FILE: src/caffe/test/test_data_layer.cpp
  type caffe (line 18) | namespace caffe {
    class DataLayerTest (line 23) | class DataLayerTest : public MultiDeviceTest<TypeParam> {
      method DataLayerTest (line 27) | DataLayerTest()
      method SetUp (line 32) | virtual void SetUp() {
      method Fill (line 43) | void Fill(const bool unique_pixels, DataParameter_DB backend) {
      method TestRead (line 70) | void TestRead() {
      method TestReshape (line 108) | void TestReshape(DataParameter_DB backend) {
      method TestReadCrop (line 173) | void TestReadCrop(Phase phase) {
      method TestReadCropTrainSequenceSeeded (line 227) | void TestReadCropTrainSequenceSeeded() {
      method TestReadCropTrainSequenceUnseeded (line 282) | void TestReadCropTrainSequenceUnseeded() {
    function TYPED_TEST (line 353) | TYPED_TEST(DataLayerTest, TestReadLevelDB) {
    function TYPED_TEST (line 359) | TYPED_TEST(DataLayerTest, TestReshapeLevelDB) {
    function TYPED_TEST (line 363) | TYPED_TEST(DataLayerTest, TestReadCropTrainLevelDB) {
    function TYPED_TEST (line 371) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceSeededLevelDB) {
    function TYPED_TEST (line 379) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceUnseededLevelDB) {
    function TYPED_TEST (line 385) | TYPED_TEST(DataLayerTest, TestReadCropTestLevelDB) {
    function TYPED_TEST (line 393) | TYPED_TEST(DataLayerTest, TestReadLMDB) {
    function TYPED_TEST (line 399) | TYPED_TEST(DataLayerTest, TestReshapeLMDB) {
    function TYPED_TEST (line 403) | TYPED_TEST(DataLayerTest, TestReadCropTrainLMDB) {
    function TYPED_TEST (line 411) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceSeededLMDB) {
    function TYPED_TEST (line 419) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceUnseededLMDB) {
    function TYPED_TEST (line 425) | TYPED_TEST(DataLayerTest, TestReadCropTestLMDB) {

FILE: src/caffe/test/test_data_transformer.cpp
  type caffe (line 17) | namespace caffe {
    class DataTransformTest (line 20) | class DataTransformTest : public ::testing::Test {
      method DataTransformTest (line 22) | DataTransformTest()
      method FillDatum (line 29) | void FillDatum(const int label, const bool unique_pixels, Datum * da...
      method FillAnnotatedDatum (line 42) | void FillAnnotatedDatum(const int label, const bool unique_pixels,
      method NumSequenceMatches (line 78) | int NumSequenceMatches(const TransformationParameter transform_param,
    function TYPED_TEST (line 120) | TYPED_TEST(DataTransformTest, TestEmptyTransform) {
    function TYPED_TEST (line 140) | TYPED_TEST(DataTransformTest, TestEmptyTransformUniquePixels) {
    function TYPED_TEST (line 160) | TYPED_TEST(DataTransformTest, TestCropSize) {
    function TYPED_TEST (line 184) | TYPED_TEST(DataTransformTest, TestCropTrain) {
    function TYPED_TEST (line 198) | TYPED_TEST(DataTransformTest, TestCropTest) {
    function TYPED_TEST (line 212) | TYPED_TEST(DataTransformTest, TestMirrorTrain) {
    function TYPED_TEST (line 225) | TYPED_TEST(DataTransformTest, TestMirrorTest) {
    function TYPED_TEST (line 238) | TYPED_TEST(DataTransformTest, TestCropMirrorTrain) {
    function TYPED_TEST (line 257) | TYPED_TEST(DataTransformTest, TestCropMirrorTest) {
    function TYPED_TEST (line 276) | TYPED_TEST(DataTransformTest, TestMeanValue) {
    function TYPED_TEST (line 294) | TYPED_TEST(DataTransformTest, TestMeanValues) {
    function TYPED_TEST (line 315) | TYPED_TEST(DataTransformTest, TestMeanFile) {
    function TYPED_TEST (line 349) | TYPED_TEST(DataTransformTest, TestRichLabel) {
    function TYPED_TEST (line 381) | TYPED_TEST(DataTransformTest, TestRichLabelCrop) {
    function TYPED_TEST (line 414) | TYPED_TEST(DataTransformTest, TestRichLabelCropMirror) {

FILE: src/caffe/test/test_db.cpp
  type caffe (line 14) | namespace caffe {
    class DBTest (line 19) | class DBTest : public ::testing::Test {
      method DBTest (line 21) | DBTest()
      method SetUp (line 25) | virtual void SetUp() {
    type TypeLevelDB (line 50) | struct TypeLevelDB {
    type TypeLMDB (line 55) | struct TypeLMDB {
    function TYPED_TEST (line 65) | TYPED_TEST(DBTest, TestGetDB) {
    function TYPED_TEST (line 69) | TYPED_TEST(DBTest, TestNext) {
    function TYPED_TEST (line 80) | TYPED_TEST(DBTest, TestSeekToFirst) {
    function TYPED_TEST (line 96) | TYPED_TEST(DBTest, TestKeyValue) {
    function TYPED_TEST (line 120) | TYPED_TEST(DBTest, TestWrite) {

FILE: src/caffe/test/test_deconvolution_layer.cpp
  type caffe (line 13) | namespace caffe {
    class DeconvolutionLayerTest (line 18) | class DeconvolutionLayerTest : public MultiDeviceTest<TypeParam> {
      method DeconvolutionLayerTest (line 22) | DeconvolutionLayerTest()
      method SetUp (line 27) | virtual void SetUp() {
    function TYPED_TEST (line 55) | TYPED_TEST(DeconvolutionLayerTest, TestSetup) {
    function TYPED_TEST (line 91) | TYPED_TEST(DeconvolutionLayerTest, TestSimpleDeconvolution) {
    function TYPED_TEST (line 139) | TYPED_TEST(DeconvolutionLayerTest, TestGradient) {
    function TYPED_TEST (line 157) | TYPED_TEST(DeconvolutionLayerTest, TestNDAgainst2D) {
    function TYPED_TEST (line 275) | TYPED_TEST(DeconvolutionLayerTest, TestGradient3D) {

FILE: src/caffe/test/test_dummy_data_layer.cpp
  type caffe (line 13) | namespace caffe {
    class DummyDataLayerTest (line 16) | class DummyDataLayerTest : public CPUDeviceTest<Dtype> {
      method DummyDataLayerTest (line 18) | DummyDataLayerTest()
      method SetUp (line 23) | virtual void SetUp() {
    function TYPED_TEST (line 46) | TYPED_TEST(DummyDataLayerTest, TestOneTopConstant) {
    function TYPED_TEST (line 75) | TYPED_TEST(DummyDataLayerTest, TestTwoTopConstant) {
    function TYPED_TEST (line 113) | TYPED_TEST(DummyDataLayerTest, TestThreeTopConstantGaussianConstant) {

FILE: src/caffe/test/test_eltwise_layer.cpp
  type caffe (line 14) | namespace caffe {
    class EltwiseLayerTest (line 17) | class EltwiseLayerTest : public MultiDeviceTest<TypeParam> {
      method EltwiseLayerTest (line 21) | EltwiseLayerTest()
    function TYPED_TEST (line 54) | TYPED_TEST(EltwiseLayerTest, TestSetUp) {
    function TYPED_TEST (line 68) | TYPED_TEST(EltwiseLayerTest, TestProd) {
    function TYPED_TEST (line 87) | TYPED_TEST(EltwiseLayerTest, TestSum) {
    function TYPED_TEST (line 106) | TYPED_TEST(EltwiseLayerTest, TestSumCoeff) {
    function TYPED_TEST (line 129) | TYPED_TEST(EltwiseLayerTest, TestStableProdGradient) {
    function TYPED_TEST (line 141) | TYPED_TEST(EltwiseLayerTest, TestUnstableProdGradient) {
    function TYPED_TEST (line 153) | TYPED_TEST(EltwiseLayerTest, TestSumGradient) {
    function TYPED_TEST (line 164) | TYPED_TEST(EltwiseLayerTest, TestSumCoeffGradient) {
    function TYPED_TEST (line 178) | TYPED_TEST(EltwiseLayerTest, TestMax) {
    function TYPED_TEST (line 198) | TYPED_TEST(EltwiseLayerTest, TestMaxGradient) {

FILE: src/caffe/test/test_embed_layer.cpp
  type caffe (line 13) | namespace caffe {
    class EmbedLayerTest (line 16) | class EmbedLayerTest : public MultiDeviceTest<TypeParam> {
      method EmbedLayerTest (line 19) | EmbedLayerTest()
    function TYPED_TEST (line 38) | TYPED_TEST(EmbedLayerTest, TestSetUp) {
    function TYPED_TEST (line 54) | TYPED_TEST(EmbedLayerTest, TestForward) {
    function TYPED_TEST (line 93) | TYPED_TEST(EmbedLayerTest, TestForwardWithBias) {
    function TYPED_TEST (line 137) | TYPED_TEST(EmbedLayerTest, TestGradient) {
    function TYPED_TEST (line 157) | TYPED_TEST(EmbedLayerTest, TestGradientWithBias) {

FILE: src/caffe/test/test_euclidean_loss_layer.cpp
  type caffe (line 14) | namespace caffe {
    class EuclideanLossLayerTest (line 17) | class EuclideanLossLayerTest : public MultiDeviceTest<TypeParam> {
      method EuclideanLossLayerTest (line 21) | EuclideanLossLayerTest()
      method TestForward (line 40) | void TestForward() {
    function TYPED_TEST (line 73) | TYPED_TEST(EuclideanLossLayerTest, TestForward) {
    function TYPED_TEST (line 77) | TYPED_TEST(EuclideanLossLayerTest, TestGradient) {

FILE: src/caffe/test/test_filler.cpp
  type caffe (line 7) | namespace caffe {
    class ConstantFillerTest (line 10) | class ConstantFillerTest : public ::testing::Test {
      method ConstantFillerTest (line 12) | ConstantFillerTest()
    function TYPED_TEST (line 27) | TYPED_TEST(ConstantFillerTest, TestFill) {
    class UniformFillerTest (line 38) | class UniformFillerTest : public ::testing::Test {
      method UniformFillerTest (line 40) | UniformFillerTest()
    function TYPED_TEST (line 56) | TYPED_TEST(UniformFillerTest, TestFill) {
    class PositiveUnitballFillerTest (line 67) | class PositiveUnitballFillerTest : public ::testing::Test {
      method PositiveUnitballFillerTest (line 69) | PositiveUnitballFillerTest()
    function TYPED_TEST (line 83) | TYPED_TEST(PositiveUnitballFillerTest, TestFill) {
    class GaussianFillerTest (line 104) | class GaussianFillerTest : public ::testing::Test {
      method GaussianFillerTest (line 106) | GaussianFillerTest()
    function TYPED_TEST (line 122) | TYPED_TEST(GaussianFillerTest, TestFill) {
    class XavierFillerTest (line 144) | class XavierFillerTest : public ::testing::Test {
      method XavierFillerTest (line 146) | XavierFillerTest()
      method test_params (line 150) | virtual void test_params(FillerParameter_VarianceNorm variance_norm,
    function TYPED_TEST (line 179) | TYPED_TEST(XavierFillerTest, TestFillFanIn) {
    function TYPED_TEST (line 183) | TYPED_TEST(XavierFillerTest, TestFillFanOut) {
    function TYPED_TEST (line 187) | TYPED_TEST(XavierFillerTest, TestFillAverage) {
    class MSRAFillerTest (line 193) | class MSRAFillerTest : public ::testing::Test {
      method MSRAFillerTest (line 195) | MSRAFillerTest()
      method test_params (line 199) | virtual void test_params(FillerParameter_VarianceNorm variance_norm,
    function TYPED_TEST (line 228) | TYPED_TEST(MSRAFillerTest, TestFillFanIn) {
    function TYPED_TEST (line 232) | TYPED_TEST(MSRAFillerTest, TestFillFanOut) {
    function TYPED_TEST (line 236) | TYPED_TEST(MSRAFillerTest, TestFillAverage) {

FILE: src/caffe/test/test_filter_layer.cpp
  type caffe (line 13) | namespace caffe {
    class FilterLayerTest (line 16) | class FilterLayerTest : public MultiDeviceTest<TypeParam> {
      method FilterLayerTest (line 20) | FilterLayerTest()
      method SetUp (line 26) | virtual void SetUp() {
    function TYPED_TEST (line 67) | TYPED_TEST(FilterLayerTest, TestReshape) {
    function TYPED_TEST (line 87) | TYPED_TEST(FilterLayerTest, TestForward) {
    function TYPED_TEST (line 115) | TYPED_TEST(FilterLayerTest, TestGradient) {

FILE: src/caffe/test/test_flatten_layer.cpp
  type caffe (line 13) | namespace caffe {
    class FlattenLayerTest (line 16) | class FlattenLayerTest : public MultiDeviceTest<TypeParam> {
      method FlattenLayerTest (line 19) | FlattenLayerTest()
    function TYPED_TEST (line 39) | TYPED_TEST(FlattenLayerTest, TestSetup) {
    function TYPED_TEST (line 49) | TYPED_TEST(FlattenLayerTest, TestSetupWithAxis) {
    function TYPED_TEST (line 61) | TYPED_TEST(FlattenLayerTest, TestSetupWithEndAxis) {
    function TYPED_TEST (line 73) | TYPED_TEST(FlattenLayerTest, TestSetupWithStartAndEndAxis) {
    function TYPED_TEST (line 85) | TYPED_TEST(FlattenLayerTest, TestForward) {
    function TYPED_TEST (line 99) | TYPED_TEST(FlattenLayerTest, TestGradient) {

FILE: src/caffe/test/test_gradient_based_solver.cpp
  type caffe (line 20) | namespace caffe {
    class GradientBasedSolverTest (line 23) | class GradientBasedSolverTest : public MultiDeviceTest<TypeParam> {
      method GradientBasedSolverTest (line 27) | GradientBasedSolverTest() :
      method InitSolverFromProtoString (line 52) | virtual void InitSolverFromProtoString(const string& proto) {
      method string (line 70) | string RunLeastSquaresSolver(const Dtype learning_rate,
      method ComputeLeastSquaresUpdate (line 224) | void ComputeLeastSquaresUpdate(const Dtype learning_rate,
      method CheckLeastSquaresUpdate (line 349) | void CheckLeastSquaresUpdate(
      method CheckAccumulation (line 399) | void CheckAccumulation(const Dtype kLearningRate, const Dtype kWeigh...
      method TestLeastSquaresUpdate (line 453) | void TestLeastSquaresUpdate(const Dtype learning_rate = 1.0,
      method TestSnapshot (line 490) | void TestSnapshot(const Dtype learning_rate = 1.0,
    class SGDSolverTest (line 563) | class SGDSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 567) | virtual void InitSolver(const SolverParameter& param) {
    function TYPED_TEST (line 574) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdate) {
    function TYPED_TEST (line 578) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateLROneHundredth) {
    function TYPED_TEST (line 584) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithWeightDecay) {
    function TYPED_TEST (line 595) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithWeightDecayMultiIt...
    function TYPED_TEST (line 606) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentum) {
    function TYPED_TEST (line 617) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) {
    function TYPED_TEST (line 628) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) {
    function TYPED_TEST (line 639) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingShare) {
    function TYPED_TEST (line 651) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) {
    function TYPED_TEST (line 662) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccumSha...
    function TYPED_TEST (line 674) | TYPED_TEST(SGDSolverTest, TestSnapshot) {
    function TYPED_TEST (line 685) | TYPED_TEST(SGDSolverTest, TestSnapshotShare) {
    function TYPED_TEST (line 697) | TYPED_TEST(SGDSolverTest, TestSolverType) {
    class AdaGradSolverTest (line 704) | class AdaGradSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 708) | virtual void InitSolver(const SolverParameter& param) {
    function TYPED_TEST (line 715) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdate) {
    function TYPED_TEST (line 719) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateLROneHundre...
    function TYPED_TEST (line 725) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithWeightD...
    function TYPED_TEST (line 732) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEveryth...
    function TYPED_TEST (line 743) | TYPED_TEST(AdaGradSolverTest,
    function TYPED_TEST (line 756) | TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 767) | TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 779) | TYPED_TEST(AdaGradSolverTest, TestSnapshot) {
    function TYPED_TEST (line 790) | TYPED_TEST(AdaGradSolverTest, TestSnapshotShare) {
    class NesterovSolverTest (line 804) | class NesterovSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 808) | virtual void InitSolver(const SolverParameter& param) {
    function TYPED_TEST (line 815) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdate) {
    function TYPED_TEST (line 819) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateLROneHund...
    function TYPED_TEST (line 825) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithWeigh...
    function TYPED_TEST (line 832) | TYPED_TEST(NesterovSolverTest,
    function TYPED_TEST (line 844) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithMomen...
    function TYPED_TEST (line 855) | TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithMomentumMulti...
    function TYPED_TEST (line 866) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithEvery...
    function TYPED_TEST (line 877) | TYPED_TEST(NesterovSolverTest,
    function TYPED_TEST (line 890) | TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 901) | TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 913) | TYPED_TEST(NesterovSolverTest, TestSnapshot) {
    function TYPED_TEST (line 924) | TYPED_TEST(NesterovSolverTest, TestSnapshotShare) {
    class AdaDeltaSolverTest (line 937) | class AdaDeltaSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 941) | virtual void InitSolver(const SolverParameter& param) {
    function TYPED_TEST (line 948) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdate) {
    function TYPED_TEST (line 954) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithWeigh...
    function TYPED_TEST (line 962) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithHalfM...
    function TYPED_TEST (line 973) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithMomen...
    function TYPED_TEST (line 984) | TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithMomentumMulti...
    function TYPED_TEST (line 995) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEvery...
    function TYPED_TEST (line 1006) | TYPED_TEST(AdaDeltaSolverTest,
    function TYPED_TEST (line 1019) | TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 1030) | TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 1042) | TYPED_TEST(AdaDeltaSolverTest, TestSnapshot) {
    function TYPED_TEST (line 1053) | TYPED_TEST(AdaDeltaSolverTest, TestSnapshotShare) {
    class AdamSolverTest (line 1066) | class AdamSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 1070) | virtual void InitSolver(const SolverParameter& param) {
    function TYPED_TEST (line 1082) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdate) {
    function TYPED_TEST (line 1090) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithWeightDecay) {
    function TYPED_TEST (line 1098) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithEverything) {
    function TYPED_TEST (line 1109) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithEverythingSha...
    function TYPED_TEST (line 1121) | TYPED_TEST(AdamSolverTest, TestLeastSquaresUpdateWithEverythingAccum) {
    function TYPED_TEST (line 1132) | TYPED_TEST(AdamSolverTest, TestLeastSquaresUpdateWithEverythingAccumSh...
    function TYPED_TEST (line 1144) | TYPED_TEST(AdamSolverTest, TestSnapshot) {
    function TYPED_TEST (line 1155) | TYPED_TEST(AdamSolverTest, TestSnapshotShare) {
    class RMSPropSolverTest (line 1168) | class RMSPropSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 1172) | virtual void InitSolver(const SolverParameter& param) {
    function TYPED_TEST (line 1182) | TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithWeightD...
    function TYPED_TEST (line 1189) | TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithRmsDeca...
    function TYPED_TEST (line 1200) | TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithEveryth...
    function TYPED_TEST (line 1211) | TYPED_TEST(RMSPropSolverTest,
    function TYPED_TEST (line 1224) | TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 1235) | TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 1247) | TYPED_TEST(RMSPropSolverTest, TestSnapshot) {
    function TYPED_TEST (line 1258) | TYPED_TEST(RMSPropSolverTest, TestSnapshotShare) {

FILE: src/caffe/test/test_hdf5_output_layer.cpp
  type caffe (line 15) | namespace caffe {
    class HDF5OutputLayerTest (line 18) | class HDF5OutputLayerTest : public MultiDeviceTest<TypeParam> {
      method HDF5OutputLayerTest (line 22) | HDF5OutputLayerTest()
    function TYPED_TEST (line 73) | TYPED_TEST(HDF5OutputLayerTest, TestForward) {

FILE: src/caffe/test/test_hdf5data_layer.cpp
  type caffe (line 15) | namespace caffe {
    class HDF5DataLayerTest (line 18) | class HDF5DataLayerTest : public MultiDeviceTest<TypeParam> {
      method HDF5DataLayerTest (line 22) | HDF5DataLayerTest()
      method SetUp (line 27) | virtual void SetUp() {
    function TYPED_TEST (line 55) | TYPED_TEST(HDF5DataLayerTest, TestRead) {

FILE: src/caffe/test/test_hinge_loss_layer.cpp
  type caffe (line 14) | namespace caffe {
    class HingeLossLayerTest (line 17) | class HingeLossLayerTest : public MultiDeviceTest<TypeParam> {
      method HingeLossLayerTest (line 21) | HingeLossLayerTest()
    function TYPED_TEST (line 53) | TYPED_TEST(HingeLossLayerTest, TestGradientL1) {
    function TYPED_TEST (line 62) | TYPED_TEST(HingeLossLayerTest, TestGradientL2) {

FILE: src/caffe/test/test_im2col_layer.cpp
  type caffe (line 13) | namespace caffe {
    class Im2colLayerTest (line 16) | class Im2colLayerTest : public MultiDeviceTest<TypeParam> {
      method Im2colLayerTest (line 19) | Im2colLayerTest()
    function TYPED_TEST (line 39) | TYPED_TEST(Im2colLayerTest, TestSetup) {
    function TYPED_TEST (line 61) | TYPED_TEST(Im2colLayerTest, TestForward) {
    function TYPED_TEST (line 78) | TYPED_TEST(Im2colLayerTest, TestGradient) {
    function TYPED_TEST (line 91) | TYPED_TEST(Im2colLayerTest, TestDilatedGradient) {
    function TYPED_TEST (line 111) | TYPED_TEST(Im2colLayerTest, TestGradientForceND) {
    function TYPED_TEST (line 125) | TYPED_TEST(Im2colLayerTest, TestDilatedGradientForceND) {
    function TYPED_TEST (line 146) | TYPED_TEST(Im2colLayerTest, TestRect) {
    function TYPED_TEST (line 164) | TYPED_TEST(Im2colLayerTest, TestRectGradient) {

FILE: src/caffe/test/test_im_transforms.cpp
  type caffe (line 8) | namespace caffe {
    class ImTransformsTest (line 12) | class ImTransformsTest : public CPUDeviceTest<float> {
    function TEST_F (line 15) | TEST_F(ImTransformsTest, TestUpdateBBoxByResizePolicy) {
    function TEST_F (line 72) | TEST_F(ImTransformsTest, TestApplyResize) {

FILE: src/caffe/test/test_image_data_layer.cpp
  type caffe (line 17) | namespace caffe {
    class ImageDataLayerTest (line 20) | class ImageDataLayerTest : public MultiDeviceTest<TypeParam> {
      method ImageDataLayerTest (line 24) | ImageDataLayerTest()
      method SetUp (line 28) | virtual void SetUp() {
    function TYPED_TEST (line 74) | TYPED_TEST(ImageDataLayerTest, TestRead) {
    function TYPED_TEST (line 100) | TYPED_TEST(ImageDataLayerTest, TestResize) {
    function TYPED_TEST (line 128) | TYPED_TEST(ImageDataLayerTest, TestReshape) {
    function TYPED_TEST (line 155) | TYPED_TEST(ImageDataLayerTest, TestShuffle) {
    function TYPED_TEST (line 189) | TYPED_TEST(ImageDataLayerTest, TestSpace) {

FILE: src/caffe/test/test_infogain_loss_layer.cpp
  type caffe (line 13) | namespace caffe {
    class InfogainLossLayerTest (line 16) | class InfogainLossLayerTest : public MultiDeviceTest<TypeParam> {
      method InfogainLossLayerTest (line 20) | InfogainLossLayerTest()
    function TYPED_TEST (line 58) | TYPED_TEST(InfogainLossLayerTest, TestGradient) {

FILE: src/caffe/test/test_inner_product_layer.cpp
  type caffe (line 13) | namespace caffe {
    class InnerProductLayerTest (line 20) | class InnerProductLayerTest : public MultiDeviceTest<TypeParam> {
      method InnerProductLayerTest (line 23) | InnerProductLayerTest()
    function TYPED_TEST (line 47) | TYPED_TEST(InnerProductLayerTest, TestSetUp) {
    function TYPED_TEST (line 65) | TYPED_TEST(InnerProductLayerTest, TestSetUpTranposeFalse) {
    function TYPED_TEST (line 87) | TYPED_TEST(InnerProductLayerTest, TestSetUpTranposeTrue) {
    function TYPED_TEST (line 107) | TYPED_TEST(InnerProductLayerTest, TestForward) {
    function TYPED_TEST (line 145) | TYPED_TEST(InnerProductLayerTest, TestForwardTranspose) {
    function TYPED_TEST (line 211) | TYPED_TEST(InnerProductLayerTest, TestForwardNoBatch) {
    function TYPED_TEST (line 242) | TYPED_TEST(InnerProductLayerTest, TestGradient) {
    function TYPED_TEST (line 268) | TYPED_TEST(InnerProductLayerTest, TestGradientTranspose) {
    function TYPED_TEST (line 295) | TYPED_TEST(InnerProductLayerTest, TestBackwardTranspose) {

FILE: src/caffe/test/test_internal_thread.cpp
  type caffe (line 9) | namespace caffe {
    class InternalThreadTest (line 12) | class InternalThreadTest : public ::testing::Test {}
    function TEST_F (line 14) | TEST_F(InternalThreadTest, TestStartAndExit) {
    class TestThreadA (line 23) | class TestThreadA : public InternalThread {
      method InternalThreadEntry (line 24) | void InternalThreadEntry() {
    class TestThreadB (line 29) | class TestThreadB : public InternalThread {
      method InternalThreadEntry (line 30) | void InternalThreadEntry() {
    function TEST_F (line 35) | TEST_F(InternalThreadTest, TestRandomSeed) {

FILE: src/caffe/test/test_io.cpp
  type caffe (line 16) | namespace caffe {
    class IOTest (line 18) | class IOTest : public ::testing::Test {}
    function ReadImageToDatumReference (line 20) | bool ReadImageToDatumReference(const string& filename, const int label,
    function TEST_F (line 65) | TEST_F(IOTest, TestReadImageToDatum) {
    function TEST_F (line 74) | TEST_F(IOTest, TestReadImageToDatumReference) {
    function TEST_F (line 93) | TEST_F(IOTest, TestReadImageToDatumReferenceResized) {
    function TEST_F (line 111) | TEST_F(IOTest, TestReadImageToDatumContent) {
    function TEST_F (line 132) | TEST_F(IOTest, TestReadImageToDatumContentGray) {
    function TEST_F (line 151) | TEST_F(IOTest, TestReadImageToDatumResized) {
    function TEST_F (line 160) | TEST_F(IOTest, TestReadImageToDatumResizedMinDim) {
    function TEST_F (line 179) | TEST_F(IOTest, TestReadImageToDatumResizedMaxDim) {
    function TEST_F (line 198) | TEST_F(IOTest, TestReadImageToDatumResizedSquare) {
    function TEST_F (line 207) | TEST_F(IOTest, TestReadImageToDatumGray) {
    function TEST_F (line 217) | TEST_F(IOTest, TestReadImageToDatumResizedGray) {
    function TEST_F (line 227) | TEST_F(IOTest, TestReadImageToCVMat) {
    function TEST_F (line 235) | TEST_F(IOTest, TestReadImageToCVMatResized) {
    function TEST_F (line 243) | TEST_F(IOTest, TestReadImageToCVMatResizedSquare) {
    function TEST_F (line 251) | TEST_F(IOTest, TestReadImageToCVMatResizedMinDim) {
    function TEST_F (line 269) | TEST_F(IOTest, TestReadImageToCVMatResizedMaxDim) {
    function TEST_F (line 287) | TEST_F(IOTest, TestReadImageToCVMatGray) {
    function TEST_F (line 296) | TEST_F(IOTest, TestReadImageToCVMatResizedGray) {
    function TEST_F (line 305) | TEST_F(IOTest, TestCVMatToDatum) {
    function TEST_F (line 315) | TEST_F(IOTest, TestCVMatToDatumContent) {
    function TEST_F (line 334) | TEST_F(IOTest, TestCVMatToDatumReference) {
    function TEST_F (line 353) | TEST_F(IOTest, TestReadFileToDatum) {
    function TEST_F (line 362) | TEST_F(IOTest, TestDecodeDatum) {
    function TEST_F (line 382) | TEST_F(IOTest, TestDecodeDatumToCVMat) {
    function TEST_F (line 396) | TEST_F(IOTest, TestDecodeDatumToCVMatContent) {
    function TEST_F (line 416) | TEST_F(IOTest, TestDecodeDatumNative) {
    function TEST_F (line 436) | TEST_F(IOTest, TestDecodeDatumToCVMatNative) {
    function TEST_F (line 446) | TEST_F(IOTest, TestDecodeDatumNativeGray) {
    function TEST_F (line 466) | TEST_F(IOTest, TestDecodeDatumToCVMatNativeGray) {
    function TEST_F (line 476) | TEST_F(IOTest, TestDecodeDatumToCVMatContentNative) {

FILE: src/caffe/test/test_layer_factory.cpp
  type caffe (line 15) | namespace caffe {
    class LayerFactoryTest (line 18) | class LayerFactoryTest : public MultiDeviceTest<TypeParam> {}
    function TYPED_TEST (line 22) | TYPED_TEST(LayerFactoryTest, TestCreateLayer) {

FILE: src/caffe/test/test_lrn_layer.cpp
  type caffe (line 22) | namespace caffe {
    class LRNLayerTest (line 25) | class LRNLayerTest : public MultiDeviceTest<TypeParam> {
      method LRNLayerTest (line 29) | LRNLayerTest()
      method SetUp (line 33) | virtual void SetUp() {
    function TYPED_TEST (line 119) | TYPED_TEST(LRNLayerTest, TestSetupAcrossChannels) {
    function TYPED_TEST (line 130) | TYPED_TEST(LRNLayerTest, TestForwardAcrossChannels) {
    function TYPED_TEST (line 145) | TYPED_TEST(LRNLayerTest, TestForwardAcrossChannelsLargeRegion) {
    function TYPED_TEST (line 161) | TYPED_TEST(LRNLayerTest, TestGradientAcrossChannels) {
    function TYPED_TEST (line 182) | TYPED_TEST(LRNLayerTest, TestGradientAcrossChannelsLargeRegion) {
    function TYPED_TEST (line 204) | TYPED_TEST(LRNLayerTest, TestSetupWithinChannel) {
    function TYPED_TEST (line 218) | TYPED_TEST(LRNLayerTest, TestForwardWithinChannel) {
    function TYPED_TEST (line 236) | TYPED_TEST(LRNLayerTest, TestGradientWithinChannel) {
    class CuDNNLRNLayerTest (line 255) | class CuDNNLRNLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNLRNLayerTest (line 257) | CuDNNLRNLayerTest()
      method SetUp (line 261) | virtual void SetUp() {
    function TYPED_TEST (line 347) | TYPED_TEST(CuDNNLRNLayerTest, TestForwardAcrossChannelsCuDNN) {
    function TYPED_TEST (line 362) | TYPED_TEST(CuDNNLRNLayerTest, TestForwardAcrossChannelsLargeRegionCuDN...
    function TYPED_TEST (line 378) | TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsCuDNN) {
    function TYPED_TEST (line 395) | TYPED_TEST(CuDNNLRNLayerTest, TestForwardWithinChannel) {
    function TYPED_TEST (line 413) | TYPED_TEST(CuDNNLRNLayerTest, TestGradientWithinChannel) {
    function TYPED_TEST (line 430) | TYPED_TEST(CuDNNLRNLayerTest, TestGradientAcrossChannelsLargeRegionCuD...

FILE: src/caffe/test/test_lstm_layer.cpp
  type caffe (line 14) | namespace caffe {
    class LSTMLayerTest (line 17) | class LSTMLayerTest : public MultiDeviceTest<TypeParam> {
      method LSTMLayerTest (line 21) | LSTMLayerTest() : num_output_(7) {
      method ReshapeBlobs (line 46) | void ReshapeBlobs(int num_timesteps, int num_instances) {
    function TYPED_TEST (line 92) | TYPED_TEST(LSTMLayerTest, TestSetUp) {
    function TYPED_TEST (line 102) | TYPED_TEST(LSTMLayerTest, TestForward) {
    function TYPED_TEST (line 188) | TYPED_TEST(LSTMLayerTest, TestLSTMUnitSetUp) {
    function TYPED_TEST (line 204) | TYPED_TEST(LSTMLayerTest, TestLSTMUnitGradient) {
    function TYPED_TEST (line 219) | TYPED_TEST(LSTMLayerTest, TestLSTMUnitGradientNonZeroCont) {
    function TYPED_TEST (line 234) | TYPED_TEST(LSTMLayerTest, TestGradient) {
    function TYPED_TEST (line 242) | TYPED_TEST(LSTMLayerTest, TestGradientNonZeroCont) {
    function TYPED_TEST (line 253) | TYPED_TEST(LSTMLayerTest, TestGradientNonZeroContBufferSize2) {
    function TYPED_TEST (line 268) | TYPED_TEST(LSTMLayerTest, TestGradientNonZeroContBufferSize2WithStatic...

FILE: src/caffe/test/test_math_functions.cpp
  type caffe (line 14) | namespace caffe {
    class MathFunctionsTest (line 17) | class MathFunctionsTest : public MultiDeviceTest<TypeParam> {
      method MathFunctionsTest (line 21) | MathFunctionsTest()
      method SetUp (line 26) | virtual void SetUp() {
    class CPUMathFunctionsTest (line 47) | class CPUMathFunctionsTest
    function TYPED_TEST (line 53) | TYPED_TEST(CPUMathFunctionsTest, TestNothing) {
    function TYPED_TEST (line 58) | TYPED_TEST(CPUMathFunctionsTest, TestAsum) {
    function TYPED_TEST (line 69) | TYPED_TEST(CPUMathFunctionsTest, TestSign) {
    function TYPED_TEST (line 79) | TYPED_TEST(CPUMathFunctionsTest, TestSgnbit) {
    function TYPED_TEST (line 89) | TYPED_TEST(CPUMathFunctionsTest, TestFabs) {
    function TYPED_TEST (line 99) | TYPED_TEST(CPUMathFunctionsTest, TestScale) {
    function TYPED_TEST (line 112) | TYPED_TEST(CPUMathFunctionsTest, TestCopy) {
    class GPUMathFunctionsTest (line 125) | class GPUMathFunctionsTest : public MathFunctionsTest<GPUDevice<Dtype>...
    function TYPED_TEST (line 130) | TYPED_TEST(GPUMathFunctionsTest, TestAsum) {
    function TYPED_TEST (line 142) | TYPED_TEST(GPUMathFunctionsTest, TestSign) {
    function TYPED_TEST (line 153) | TYPED_TEST(GPUMathFunctionsTest, TestSgnbit) {
    function TYPED_TEST (line 164) | TYPED_TEST(GPUMathFunctionsTest, TestFabs) {
    function TYPED_TEST (line 175) | TYPED_TEST(GPUMathFunctionsTest, TestScale) {
    function TYPED_TEST (line 188) | TYPED_TEST(GPUMathFunctionsTest, TestCopy) {

FILE: src/caffe/test/test_maxpool_dropout_layers.cpp
  type caffe (line 14) | namespace caffe {
    class MaxPoolingDropoutTest (line 17) | class MaxPoolingDropoutTest : public MultiDeviceTest<TypeParam> {
      method MaxPoolingDropoutTest (line 20) | MaxPoolingDropoutTest()
      method SetUp (line 23) | virtual void SetUp() {
    function TYPED_TEST (line 43) | TYPED_TEST(MaxPoolingDropoutTest, TestSetup) {
    function TYPED_TEST (line 60) | TYPED_TEST(MaxPoolingDropoutTest, TestForward) {
    function TYPED_TEST (line 89) | TYPED_TEST(MaxPoolingDropoutTest, TestBackward) {

FILE: src/caffe/test/test_memory_data_layer.cpp
  type caffe (line 13) | namespace caffe {
    class MemoryDataLayerTest (line 16) | class MemoryDataLayerTest : public MultiDeviceTest<TypeParam> {
      method MemoryDataLayerTest (line 20) | MemoryDataLayerTest()
      method SetUp (line 25) | virtual void SetUp() {
    function TYPED_TEST (line 66) | TYPED_TEST(MemoryDataLayerTest, TestSetup) {
    function TYPED_TEST (line 89) | TYPED_TEST(MemoryDataLayerTest, TestForward) {
    function TYPED_TEST (line 119) | TYPED_TEST(MemoryDataLayerTest, AddDatumVectorDefaultTransform) {
    function TYPED_TEST (line 173) | TYPED_TEST(MemoryDataLayerTest, AddMatVectorDefaultTransform) {
    function TYPED_TEST (line 219) | TYPED_TEST(MemoryDataLayerTest, TestSetBatchSize) {

FILE: src/caffe/test/test_multinomial_logistic_loss_layer.cpp
  type caffe (line 13) | namespace caffe {
    class MultinomialLogisticLossLayerTest (line 16) | class MultinomialLogisticLossLayerTest : public CPUDeviceTest<Dtype> {
      method MultinomialLogisticLossLayerTest (line 18) | MultinomialLogisticLossLayerTest()
    function TYPED_TEST (line 49) | TYPED_TEST(MultinomialLogisticLossLayerTest, TestGradientCPU) {

FILE: src/caffe/test/test_mvn_layer.cpp
  type caffe (line 13) | namespace caffe {
    class MVNLayerTest (line 16) | class MVNLayerTest : public MultiDeviceTest<TypeParam> {
      method MVNLayerTest (line 19) | MVNLayerTest()
    function TYPED_TEST (line 38) | TYPED_TEST(MVNLayerTest, TestForward) {
    function TYPED_TEST (line 72) | TYPED_TEST(MVNLayerTest, TestForwardMeanOnly) {
    function TYPED_TEST (line 105) | TYPED_TEST(MVNLayerTest, TestForwardAcrossChannels) {
    function TYPED_TEST (line 141) | TYPED_TEST(MVNLayerTest, TestGradient) {
    function TYPED_TEST (line 150) | TYPED_TEST(MVNLayerTest, TestGradientMeanOnly) {
    function TYPED_TEST (line 161) | TYPED_TEST(MVNLayerTest, TestGradientAcrossChannels) {

FILE: src/caffe/test/test_net.cpp
  type caffe (line 18) | namespace caffe {
    class NetTest (line 21) | class NetTest : public MultiDeviceTest<TypeParam> {
      method NetTest (line 25) | NetTest() : seed_(1701) {}
      method InitNetFromProtoString (line 27) | virtual void InitNetFromProtoString(const string& proto) {
      method InitNetFromProtoFileWithState (line 33) | virtual void InitNetFromProtoFileWithState(const string& proto,
      method CopyNetBlobs (line 44) | virtual void CopyNetBlobs(const bool copy_diff,
      method CopyNetParams (line 57) | virtual void CopyNetParams(const bool copy_diff,
      method InitTinyNet (line 70) | virtual void InitTinyNet(const bool force_backward = false,
      method InitTinyNetEuclidean (line 147) | virtual void InitTinyNetEuclidean(const bool force_backward = false) {
      method InitTrickyNet (line 207) | virtual void InitTrickyNet(Dtype* loss_weight = NULL) {
      method InitUnsharedWeightsNet (line 298) | virtual void InitUnsharedWeightsNet(const Dtype* loss_weight = NULL,
      method InitSharedWeightsNet (line 386) | virtual void InitSharedWeightsNet() {
      method InitDiffDataUnsharedWeightsNet (line 443) | virtual void InitDiffDataUnsharedWeightsNet() {
      method InitDiffDataSharedWeightsNet (line 505) | virtual void InitDiffDataSharedWeightsNet() {
      method InitReshapableNet (line 567) | virtual void InitReshapableNet() {
      method InitSkipPropNet (line 632) | virtual void InitSkipPropNet(bool test_skip_true) {
      method InitForcePropNet (line 731) | virtual void InitForcePropNet(bool test_force_true) {
      method InitAllInOneNet (line 786) | virtual void InitAllInOneNet(Phase phase = caffe::TRAIN,
    function TYPED_TEST (line 848) | TYPED_TEST(NetTest, TestHasBlob) {
    function TYPED_TEST (line 857) | TYPED_TEST(NetTest, TestGetBlob) {
    function TYPED_TEST (line 866) | TYPED_TEST(NetTest, TestHasLayer) {
    function TYPED_TEST (line 874) | TYPED_TEST(NetTest, TestGetLayerByName) {
    function TYPED_TEST (line 882) | TYPED_TEST(NetTest, TestBottomNeedBackward) {
    function TYPED_TEST (line 895) | TYPED_TEST(NetTest, TestBottomNeedBackwardForce) {
    function TYPED_TEST (line 909) | TYPED_TEST(NetTest, TestBottomNeedBackwardEuclideanForce) {
    function TYPED_TEST (line 923) | TYPED_TEST(NetTest, TestBottomNeedBackwardTricky) {
    function TYPED_TEST (line 941) | TYPED_TEST(NetTest, TestLossWeight) {
    function TYPED_TEST (line 992) | TYPED_TEST(NetTest, TestLossWeightMidNet) {
    function TYPED_TEST (line 1029) | TYPED_TEST(NetTest, TestComboLossWeight) {
    function TYPED_TEST (line 1158) | TYPED_TEST(NetTest, TestBackwardWithAccuracyLayer) {
    function TYPED_TEST (line 1167) | TYPED_TEST(NetTest, TestUnsharedWeightsDataNet) {
    function TYPED_TEST (line 1175) | TYPED_TEST(NetTest, TestSharedWeightsDataNet) {
    function TYPED_TEST (line 1183) | TYPED_TEST(NetTest, TestUnsharedWeightsDiffNet) {
    function TYPED_TEST (line 1200) | TYPED_TEST(NetTest, TestSharedWeightsDiffNet) {
    function TYPED_TEST (line 1219) | TYPED_TEST(NetTest, TestSharedWeightsUpdate) {
    function TYPED_TEST (line 1300) | TYPED_TEST(NetTest, TestSharedWeightsResume) {
    function TYPED_TEST (line 1345) | TYPED_TEST(NetTest, TestParamPropagateDown) {
    function TYPED_TEST (line 1426) | TYPED_TEST(NetTest, TestFromTo) {
    class FilterNetTest (line 1460) | class FilterNetTest : public ::testing::Test {
      method RunFilterNetTest (line 1462) | void RunFilterNetTest(
    function TEST_F (line 1482) | TEST_F(FilterNetTest, TestNoFilter) {
    function TEST_F (line 1506) | TEST_F(FilterNetTest, TestFilterLeNetTrainTest) {
    function TEST_F (line 1748) | TEST_F(FilterNetTest, TestFilterOutByStage) {
    function TEST_F (line 1787) | TEST_F(FilterNetTest, TestFilterOutByStage2) {
    function TEST_F (line 1826) | TEST_F(FilterNetTest, TestFilterInByStage) {
    function TEST_F (line 1852) | TEST_F(FilterNetTest, TestFilterInByStage2) {
    function TEST_F (line 1877) | TEST_F(FilterNetTest, TestFilterOutByMultipleStage) {
    function TEST_F (line 1920) | TEST_F(FilterNetTest, TestFilterInByMultipleStage) {
    function TEST_F (line 1948) | TEST_F(FilterNetTest, TestFilterInByMultipleStage2) {
    function TEST_F (line 1975) | TEST_F(FilterNetTest, TestFilterInByNotStage) {
    function TEST_F (line 2002) | TEST_F(FilterNetTest, TestFilterOutByNotStage) {
    function TEST_F (line 2038) | TEST_F(FilterNetTest, TestFilterOutByMinLevel) {
    function TEST_F (line 2077) | TEST_F(FilterNetTest, TestFilterOutByMaxLevel) {
    function TEST_F (line 2116) | TEST_F(FilterNetTest, TestFilterInByMinLevel) {
    function TEST_F (line 2141) | TEST_F(FilterNetTest, TestFilterInByMinLevel2) {
    function TEST_F (line 2167) | TEST_F(FilterNetTest, TestFilterInByMaxLevel) {
    function TEST_F (line 2192) | TEST_F(FilterNetTest, TestFilterInByMaxLevel2) {
    function TEST_F (line 2218) | TEST_F(FilterNetTest, TestFilterInOutByIncludeMultiRule) {
    function TEST_F (line 2281) | TEST_F(FilterNetTest, TestFilterInByIncludeMultiRule) {
    function TEST_F (line 2314) | TEST_F(FilterNetTest, TestFilterInOutByExcludeMultiRule) {
    function TYPED_TEST (line 2377) | TYPED_TEST(NetTest, TestReshape) {
    function TYPED_TEST (line 2449) | TYPED_TEST(NetTest, TestSkipPropagateDown) {
    function TYPED_TEST (line 2497) | TYPED_TEST(NetTest, TestForcePropagateDown) {
    function TYPED_TEST (line 2544) | TYPED_TEST(NetTest, TestAllInOneNetTrain) {
    function TYPED_TEST (line 2565) | TYPED_TEST(NetTest, TestAllInOneNetVal) {
    function TYPED_TEST (line 2586) | TYPED_TEST(NetTest, TestAllInOneNetDeploy) {

FILE: src/caffe/test/test_neuron_layer.cpp
  type caffe (line 34) | namespace caffe {
    class NeuronLayerTest (line 37) | class NeuronLayerTest : public MultiDeviceTest<TypeParam> {
      method NeuronLayerTest (line 41) | NeuronLayerTest()
      method TestDropoutForward (line 58) | void TestDropoutForward(const float dropout_ratio) {
      method TestExpForward (line 90) | void TestExpForward(const float base, const float scale, const float...
      method TestExpGradient (line 112) | void TestExpGradient(const float base, const float scale, const floa...
      method TestPReLU (line 122) | void TestPReLU(PReLULayer<Dtype> *layer) {
      method LogBottomInit (line 139) | void LogBottomInit() {
      method TestLogForward (line 147) | void TestLogForward(const float base, const float scale, const float...
      method TestLogGradient (line 171) | void TestLogGradient(const float base, const float scale, const floa...
    function TYPED_TEST (line 185) | TYPED_TEST(NeuronLayerTest, TestAbsVal) {
    function TYPED_TEST (line 199) | TYPED_TEST(NeuronLayerTest, TestAbsGradient) {
    function TYPED_TEST (line 208) | TYPED_TEST(NeuronLayerTest, TestReLU) {
    function TYPED_TEST (line 223) | TYPED_TEST(NeuronLayerTest, TestReLUGradient) {
    function TYPED_TEST (line 232) | TYPED_TEST(NeuronLayerTest, TestReLUWithNegativeSlope) {
    function TYPED_TEST (line 252) | TYPED_TEST(NeuronLayerTest, TestReLUGradientWithNegativeSlope) {
    function TYPED_TEST (line 263) | TYPED_TEST(NeuronLayerTest, TestELU) {
    function TYPED_TEST (line 284) | TYPED_TEST(NeuronLayerTest, TestELUasReLU) {
    function TYPED_TEST (line 301) | TYPED_TEST(NeuronLayerTest, TestELUGradient) {
    function TYPED_TEST (line 310) | TYPED_TEST(NeuronLayerTest, TestELUasReLUGradient) {
    function TYPED_TEST (line 321) | TYPED_TEST(NeuronLayerTest, TestSigmoid) {
    function TYPED_TEST (line 338) | TYPED_TEST(NeuronLayerTest, TestSigmoidGradient) {
    function TYPED_TEST (line 347) | TYPED_TEST(NeuronLayerTest, TestTanH) {
    function TYPED_TEST (line 370) | TYPED_TEST(NeuronLayerTest, TestTanHGradient) {
    function TYPED_TEST (line 379) | TYPED_TEST(NeuronLayerTest, TestExpLayer) {
    function TYPED_TEST (line 388) | TYPED_TEST(NeuronLayerTest, TestExpGradient) {
    function TYPED_TEST (line 397) | TYPED_TEST(NeuronLayerTest, TestExpLayerWithShift) {
    function TYPED_TEST (line 407) | TYPED_TEST(NeuronLayerTest, TestExpGradientWithShift) {
    function TYPED_TEST (line 417) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2) {
    function TYPED_TEST (line 425) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2) {
    function TYPED_TEST (line 433) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2Shift1) {
    function TYPED_TEST (line 441) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2Shift1) {
    function TYPED_TEST (line 449) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2Scale3) {
    function TYPED_TEST (line 457) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2Scale3) {
    function TYPED_TEST (line 465) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2Shift1Scale3) {
    function TYPED_TEST (line 473) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2Shift1Scale3) {
    function TYPED_TEST (line 481) | TYPED_TEST(NeuronLayerTest, TestLogLayer) {
    function TYPED_TEST (line 490) | TYPED_TEST(NeuronLayerTest, TestLogGradient) {
    function TYPED_TEST (line 499) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2) {
    function TYPED_TEST (line 507) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2) {
    function TYPED_TEST (line 515) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Shift1) {
    function TYPED_TEST (line 523) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Shift1) {
    function TYPED_TEST (line 531) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Scale3) {
    function TYPED_TEST (line 539) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Scale3) {
    function TYPED_TEST (line 547) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Shift1Scale3) {
    function TYPED_TEST (line 555) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Shift1Scale3) {
    function TYPED_TEST (line 563) | TYPED_TEST(NeuronLayerTest, TestDropoutHalf) {
    function TYPED_TEST (line 568) | TYPED_TEST(NeuronLayerTest, TestDropoutThreeQuarters) {
    function TYPED_TEST (line 573) | TYPED_TEST(NeuronLayerTest, TestDropoutTestPhase) {
    function TYPED_TEST (line 590) | TYPED_TEST(NeuronLayerTest, TestDropoutGradient) {
    function TYPED_TEST (line 600) | TYPED_TEST(NeuronLayerTest, TestDropoutGradientTest) {
    function TYPED_TEST (line 610) | TYPED_TEST(NeuronLayerTest, TestBNLL) {
    function TYPED_TEST (line 625) | TYPED_TEST(NeuronLayerTest, TestBNLLGradient) {
    function TYPED_TEST (line 634) | TYPED_TEST(NeuronLayerTest, TestPReLUParam) {
    function TYPED_TEST (line 646) | TYPED_TEST(NeuronLayerTest, TestPReLUForward) {
    function TYPED_TEST (line 657) | TYPED_TEST(NeuronLayerTest, TestPReLUForwardChannelShared) {
    function TYPED_TEST (line 666) | TYPED_TEST(NeuronLayerTest, TestPReLUGradient) {
    function TYPED_TEST (line 679) | TYPED_TEST(NeuronLayerTest, TestPReLUGradientChannelShared) {
    function TYPED_TEST (line 690) | TYPED_TEST(NeuronLayerTest, TestPReLUConsistencyReLU) {
    function TYPED_TEST (line 733) | TYPED_TEST(NeuronLayerTest, TestPReLUInPlace) {
    class CuDNNNeuronLayerTest (line 810) | class CuDNNNeuronLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNNeuronLayerTest (line 812) | CuDNNNeuronLayerTest()
    function TYPED_TEST (line 832) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUCuDNN) {
    function TYPED_TEST (line 846) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUGradientCuDNN) {
    function TYPED_TEST (line 854) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUWithNegativeSlopeCuDNN) {
    function TYPED_TEST (line 873) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUGradientWithNegativeSlopeCuDN...
    function TYPED_TEST (line 883) | TYPED_TEST(CuDNNNeuronLayerTest, TestSigmoidCuDNN) {
    function TYPED_TEST (line 899) | TYPED_TEST(CuDNNNeuronLayerTest, TestSigmoidGradientCuDNN) {
    function TYPED_TEST (line 907) | TYPED_TEST(CuDNNNeuronLayerTest, TestTanHCuDNN) {
    function TYPED_TEST (line 929) | TYPED_TEST(CuDNNNeuronLayerTest, TestTanHGradientCuDNN) {

FILE: src/caffe/test/test_platform.cpp
  type caffe (line 11) | namespace caffe {
    class PlatformTest (line 15) | class PlatformTest : public ::testing::Test {}
    function TEST_F (line 17) | TEST_F(PlatformTest, TestInitialization) {

FILE: src/caffe/test/test_pooling_layer.cpp
  type caffe (line 17) | namespace caffe {
    class PoolingLayerTest (line 20) | class PoolingLayerTest : public MultiDeviceTest<TypeParam> {
      method PoolingLayerTest (line 24) | PoolingLayerTest()
      method SetUp (line 28) | virtual void SetUp() {
      method TestForwardSquare (line 49) | void TestForwardSquare() {
      method TestForwardRectHigh (line 121) | void TestForwardRectHigh() {
      method TestForwardRectWide (line 246) | void TestForwardRectWide() {
    function TYPED_TEST (line 376) | TYPED_TEST(PoolingLayerTest, TestSetup) {
    function TYPED_TEST (line 390) | TYPED_TEST(PoolingLayerTest, TestSetupPadded) {
    function TYPED_TEST (line 406) | TYPED_TEST(PoolingLayerTest, TestSetupGlobalPooling) {
    function TYPED_TEST (line 446) | TYPED_TEST(PoolingLayerTest, TestForwardMax) {
    function TYPED_TEST (line 452) | TYPED_TEST(PoolingLayerTest, TestForwardMaxTopMask) {
    function TYPED_TEST (line 459) | TYPED_TEST(PoolingLayerTest, TestGradientMax) {
    function TYPED_TEST (line 478) | TYPED_TEST(PoolingLayerTest, TestForwardMaxPadded) {
    function TYPED_TEST (line 523) | TYPED_TEST(PoolingLayerTest, TestGradientMaxTopMask) {
    function TYPED_TEST (line 543) | TYPED_TEST(PoolingLayerTest, TestForwardAve) {
    function TYPED_TEST (line 575) | TYPED_TEST(PoolingLayerTest, TestGradientAve) {
    function TYPED_TEST (line 593) | TYPED_TEST(PoolingLayerTest, TestGradientAvePadded) {
    class CuDNNPoolingLayerTest (line 614) | class CuDNNPoolingLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNPoolingLayerTest (line 616) | CuDNNPoolingLayerTest()
      method SetUp (line 620) | virtual void SetUp() {
      method TestForwardSquare (line 641) | void TestForwardSquare() {
      method TestForwardRectHigh (line 713) | void TestForwardRectHigh() {
      method TestForwardRectWide (line 838) | void TestForwardRectWide() {
    function TYPED_TEST (line 968) | TYPED_TEST(CuDNNPoolingLayerTest, TestSetupCuDNN) {
    function TYPED_TEST (line 981) | TYPED_TEST(CuDNNPoolingLayerTest, TestSetupPaddedCuDNN) {
    function TYPED_TEST (line 1022) | TYPED_TEST(CuDNNPoolingLayerTest, TestForwardMaxCuDNN) {
    function TYPED_TEST (line 1039) | TYPED_TEST(CuDNNPoolingLayerTest, TestGradientMaxCuDNN) {
    function TYPED_TEST (line 1058) | TYPED_TEST(CuDNNPoolingLayerTest, TestForwardMaxPaddedCuDNN) {
    function TYPED_TEST (line 1123) | TYPED_TEST(CuDNNPoolingLayerTest, TestForwardAveCuDNN) {
    function TYPED_TEST (line 1148) | TYPED_TEST(CuDNNPoolingLayerTest, TestGradientAveCuDNN) {
    function TYPED_TEST (line 1165) | TYPED_TEST(CuDNNPoolingLayerTest, TestGradientAvePaddedCuDNN) {

FILE: src/caffe/test/test_power_layer.cpp
  type caffe (line 14) | namespace caffe {
    class PowerLayerTest (line 17) | class PowerLayerTest : public MultiDeviceTest<TypeParam> {
      method PowerLayerTest (line 21) | PowerLayerTest()
      method TestForward (line 34) | void TestForward(Dtype power, Dtype scale, Dtype shift) {
      method TestBackward (line 61) | void TestBackward(Dtype power, Dtype scale, Dtype shift) {
    function TYPED_TEST (line 90) | TYPED_TEST(PowerLayerTest, TestPower) {
    function TYPED_TEST (line 98) | TYPED_TEST(PowerLayerTest, TestPowerGradient) {
    function TYPED_TEST (line 106) | TYPED_TEST(PowerLayerTest, TestPowerGradientShiftZero) {
    function TYPED_TEST (line 114) | TYPED_TEST(PowerLayerTest, TestPowerZero) {
    function TYPED_TEST (line 122) | TYPED_TEST(PowerLayerTest, TestPowerZeroGradient) {
    function TYPED_TEST (line 130) | TYPED_TEST(PowerLayerTest, TestPowerOne) {
    function TYPED_TEST (line 138) | TYPED_TEST(PowerLayerTest, TestPowerOneGradient) {
    function TYPED_TEST (line 146) | TYPED_TEST(PowerLayerTest, TestPowerTwo) {
    function TYPED_TEST (line 154) | TYPED_TEST(PowerLayerTest, TestPowerTwoGradient) {
    function TYPED_TEST (line 162) | TYPED_TEST(PowerLayerTest, TestPowerTwoScaleHalfGradient) {

FILE: src/caffe/test/test_protobuf.cpp
  type caffe (line 12) | namespace caffe {
    class ProtoTest (line 14) | class ProtoTest : public ::testing::Test {}
    function TEST_F (line 16) | TEST_F(ProtoTest, TestSerialization) {

FILE: src/caffe/test/test_random_number_generator.cpp
  type caffe (line 11) | namespace caffe {
    class RandomNumberGeneratorTest (line 14) | class RandomNumberGeneratorTest : public ::testing::Test {
      method RandomNumberGeneratorTest (line 16) | RandomNumberGeneratorTest()
      method SetUp (line 25) | virtual void SetUp() {
      method Dtype (line 29) | Dtype sample_mean(const Dtype* const 

[
  {
    "path": ".Doxyfile",
    "chars": 101863,
    "preview": "# Doxyfile 1.8.8\n\n# This file describes the settings to be used by the documentation system\n# doxygen (www.doxygen.org) "
  },
  {
    "path": ".gitattributes",
    "chars": 2518,
    "preview": "###############################################################################\n# Set default behavior to automatically "
  },
  {
    "path": ".gitignore",
    "chars": 1364,
    "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": 119,
    "preview": "[submodule \"models/Yolo-Model-Zoo\"]\n\tpath = models/Yolo-Model-Zoo\n\turl = https://github.com/eric612/Yolo-Model-Zoo.git\n"
  },
  {
    "path": ".travis.yml",
    "chars": 1938,
    "preview": "dist: trusty\nsudo: required\n\nlanguage: cpp\ncompiler: gcc\n\nenv:\n  global:\n    - NUM_THREADS=4\n  matrix:\n    # Use a build"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 6385,
    "preview": "cmake_minimum_required(VERSION 2.8.7)\nif(MSVC)\n  # CMake 3.4 introduced a WINDOWS_EXPORT_ALL_SYMBOLS target property tha"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 1917,
    "preview": "# Contributing\n\n## Issues\n\nSpecific Caffe design and development issues, bugs, and feature requests are maintained by Gi"
  },
  {
    "path": "CONTRIBUTORS.md",
    "chars": 620,
    "preview": "# Contributors\n\nCaffe is developed by a core set of BAIR members and the open-source community.\n\nWe thank all of our [co"
  },
  {
    "path": "INSTALL.md",
    "chars": 210,
    "preview": "# Installation\n\nSee http://caffe.berkeleyvision.org/installation.html for the latest\ninstallation instructions.\n\nCheck t"
  },
  {
    "path": "LICENSE",
    "chars": 2092,
    "preview": "COPYRIGHT\n\nAll contributions by the University of California:\nCopyright (c) 2014-2017 The Regents of the University of C"
  },
  {
    "path": "Makefile",
    "chars": 24041,
    "preview": "PROJECT := caffe\n\nCONFIG_FILE := Makefile.config\n# Explicitly check for the config file, otherwise make -k will proceed "
  },
  {
    "path": "Makefile.config.example",
    "chars": 4631,
    "preview": "## Refer to http://caffe.berkeleyvision.org/installation.html\n# Contributions simplifying and improving our build system"
  },
  {
    "path": "README.md",
    "chars": 4608,
    "preview": "# caffe-yolov3-windows\n\nA caffe implementation of MobileNet-YOLO detection network , first train on COCO trainval35k the"
  },
  {
    "path": "appveyor.yml",
    "chars": 1822,
    "preview": "version: 1.0.{build}\nclone_folder: c:\\projects\\caffe\nenvironment:\n  matrix:\n    - MSVC_VERSION: 14\n      WITH_NINJA: 0\n "
  },
  {
    "path": "caffe.cloc",
    "chars": 1180,
    "preview": "Bourne Shell\n    filter remove_matches ^\\s*#\n    filter remove_inline #.*$\n    extension sh\n    script_exe sh\nC\n    filt"
  },
  {
    "path": "cmake/CaffeGetPrerequisites.cmake",
    "chars": 33557,
    "preview": "# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying\n# file Copyright.txt or https://cmake.org/l"
  },
  {
    "path": "cmake/ConfigGen.cmake",
    "chars": 3120,
    "preview": "\n################################################################################################\n# Helper function to g"
  },
  {
    "path": "cmake/Cuda.cmake",
    "chars": 12021,
    "preview": "if(CPU_ONLY)\n  return()\nendif()\n\n# Known NVIDIA GPU achitectures Caffe can be compiled for.\n# This list will be used for"
  },
  {
    "path": "cmake/Dependencies.cmake",
    "chars": 7985,
    "preview": "# These lists are later turned into target properties on main caffe library target\nset(Caffe_LINKER_LIBS \"\")\nset(Caffe_I"
  },
  {
    "path": "cmake/External/gflags.cmake",
    "chars": 1939,
    "preview": "if (NOT __GFLAGS_INCLUDED) # guard against multiple includes\n  set(__GFLAGS_INCLUDED TRUE)\n\n  # use the system-wide gfla"
  },
  {
    "path": "cmake/External/glog.cmake",
    "chars": 1777,
    "preview": "# glog depends on gflags\ninclude(\"cmake/External/gflags.cmake\")\n\nif (NOT __GLOG_INCLUDED)\n  set(__GLOG_INCLUDED TRUE)\n\n "
  },
  {
    "path": "cmake/External/nccl.cmake",
    "chars": 1208,
    "preview": "# if (NOT __NCCL_INCLUDED) # guard against multiple includes\n  set(__NCCL_INCLUDED TRUE)\n  if(MSVC)\n    # use the system"
  },
  {
    "path": "cmake/Misc.cmake",
    "chars": 1764,
    "preview": "# ---[ Configuration types\nset(CMAKE_CONFIGURATION_TYPES \"Debug;Release\" CACHE STRING \"Possible configurations\" FORCE)\nm"
  },
  {
    "path": "cmake/Modules/FindAtlas.cmake",
    "chars": 1724,
    "preview": "# Find the Atlas (and Lapack) libraries\n#\n# The following variables are optionally searched for defaults\n#  Atlas_ROOT_D"
  },
  {
    "path": "cmake/Modules/FindGFlags.cmake",
    "chars": 1232,
    "preview": "# - Try to find GFLAGS\n#\n# The following variables are optionally searched for defaults\n#  GFLAGS_ROOT_DIR:            B"
  },
  {
    "path": "cmake/Modules/FindGlog.cmake",
    "chars": 1169,
    "preview": "# - Try to find Glog\n#\n# The following variables are optionally searched for defaults\n#  GLOG_ROOT_DIR:            Base "
  },
  {
    "path": "cmake/Modules/FindLAPACK.cmake",
    "chars": 6723,
    "preview": "# - Find LAPACK library\n# This module finds an installed fortran library that implements the LAPACK\n# linear-algebra int"
  },
  {
    "path": "cmake/Modules/FindLMDB.cmake",
    "chars": 1178,
    "preview": "# Try to find the LMBD libraries and headers\n#  LMDB_FOUND - system has LMDB lib\n#  LMDB_INCLUDE_DIR - the LMDB include "
  },
  {
    "path": "cmake/Modules/FindLevelDB.cmake",
    "chars": 1889,
    "preview": "# - Find LevelDB\n#\n#  LevelDB_INCLUDES  - List of LevelDB includes\n#  LevelDB_LIBRARIES - List of libraries when using L"
  },
  {
    "path": "cmake/Modules/FindMKL.cmake",
    "chars": 3250,
    "preview": "# Find the MKL libraries\n#\n# Options:\n#\n#   MKL_USE_SINGLE_DYNAMIC_LIBRARY  : use single dynamic library interface\n#   M"
  },
  {
    "path": "cmake/Modules/FindMatlabMex.cmake",
    "chars": 1749,
    "preview": "# This module looks for MatlabMex compiler\n# Defines variables:\n#    Matlab_DIR    - Matlab root dir\n#    Matlab_mex    "
  },
  {
    "path": "cmake/Modules/FindNCCL.cmake",
    "chars": 654,
    "preview": "set(NCCL_INC_PATHS\n    /usr/include\n    /usr/local/include\n    $ENV{NCCL_DIR}/include\n    )\n\nset(NCCL_LIB_PATHS\n    /lib"
  },
  {
    "path": "cmake/Modules/FindNumPy.cmake",
    "chars": 2333,
    "preview": "# - Find the NumPy libraries\n# This module finds if NumPy is installed, and sets the following variables\n# indicating wh"
  },
  {
    "path": "cmake/Modules/FindOpenBLAS.cmake",
    "chars": 1709,
    "preview": "\n\nSET(Open_BLAS_INCLUDE_SEARCH_PATHS\n  /usr/include\n  /usr/include/openblas\n  /usr/include/openblas-base\n  /usr/local/in"
  },
  {
    "path": "cmake/Modules/FindSnappy.cmake",
    "chars": 1166,
    "preview": "# Find the Snappy libraries\n#\n# The following variables are optionally searched for defaults\n#  Snappy_ROOT_DIR:    Base"
  },
  {
    "path": "cmake/Modules/FindvecLib.cmake",
    "chars": 1326,
    "preview": "# Find the vecLib libraries as part of Accelerate.framework or as standalon framework\n#\n# The following are set after co"
  },
  {
    "path": "cmake/ProtoBuf.cmake",
    "chars": 3907,
    "preview": "# Finds Google Protocol Buffers library and compilers and extends\n# the standard cmake script with version and python ge"
  },
  {
    "path": "cmake/Summary.cmake",
    "chars": 7651,
    "preview": "################################################################################################\n# Caffe status report f"
  },
  {
    "path": "cmake/TargetResolvePrerequesites.cmake",
    "chars": 7331,
    "preview": "set(THIS_FILE ${CMAKE_CURRENT_LIST_FILE})\nset(THIS_DIR ${CMAKE_CURRENT_LIST_DIR})\n\ninclude(CMakeParseArguments)\n\nfunctio"
  },
  {
    "path": "cmake/Targets.cmake",
    "chars": 8452,
    "preview": "################################################################################################\n# Defines global Caffe_"
  },
  {
    "path": "cmake/Templates/CaffeConfig.cmake.in",
    "chars": 2293,
    "preview": "# Config file for the Caffe package.\n#\n# Note:\n#   Caffe and this config file depends on opencv,\n#   so put `find_packag"
  },
  {
    "path": "cmake/Templates/CaffeConfigVersion.cmake.in",
    "chars": 377,
    "preview": "set(PACKAGE_VERSION \"@Caffe_VERSION@\")\n\n# Check whether the requested PACKAGE_FIND_VERSION is compatible\nif(\"${PACKAGE_V"
  },
  {
    "path": "cmake/Templates/caffe_config.h.in",
    "chars": 366,
    "preview": "/* Sources directory */\n#define SOURCE_FOLDER \"${PROJECT_SOURCE_DIR}\"\n\n/* Binaries directory */\n#define BINARY_FOLDER \"$"
  },
  {
    "path": "cmake/Templates/export.hpp.in",
    "chars": 256,
    "preview": "#ifndef CAFFE_EXPORT_HPP_\n#define CAFFE_EXPORT_HPP_\n\n// CAFFE_BUILDING_STATIC_LIB should be defined \n// only by the caff"
  },
  {
    "path": "cmake/Uninstall.cmake.in",
    "chars": 1170,
    "preview": "if(NOT EXISTS \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\")\n  message(FATAL_ERROR \"Cannot find install manifest: @C"
  },
  {
    "path": "cmake/Utils.cmake",
    "chars": 13393,
    "preview": "################################################################################################\n# Command alias for deb"
  },
  {
    "path": "cmake/WindowsCreateLinkHeader.cmake",
    "chars": 2819,
    "preview": "set(_windows_create_link_header \"${CMAKE_CURRENT_LIST_FILE}\")\n\n# function to add a post build command to create a link h"
  },
  {
    "path": "cmake/WindowsDownloadPrebuiltDependencies.cmake",
    "chars": 4686,
    "preview": "set(DEPENDENCIES_VERSION 1.1.0)\nset(DEPENDENCIES_NAME_1800_27 libraries_v120_x64_py27_${DEPENDENCIES_VERSION})\nset(DEPEN"
  },
  {
    "path": "cmake/lint.cmake",
    "chars": 1642,
    "preview": "\nset(CMAKE_SOURCE_DIR ..)\nset(python_executable)\nif(WIN32)\n  set(python_executable ${PYTHON_EXECUTABLE})\nendif()\nset(LIN"
  },
  {
    "path": "data/cifar10/get_cifar10.sh",
    "chars": 506,
    "preview": "#!/usr/bin/env sh\n# This scripts downloads the CIFAR10 (binary version) data and unzips it.\n\nDIR=\"$( cd \"$(dirname \"$0\")"
  },
  {
    "path": "data/ilsvrc12/get_ilsvrc_aux.sh",
    "chars": 587,
    "preview": "#!/usr/bin/env sh\n#\n# N.B. This does not download the ilsvrcC12 data set, as it is gargantuan.\n# This script downloads t"
  },
  {
    "path": "data/mnist/get_mnist.ps1",
    "chars": 703,
    "preview": "# This scripts downloads the mnist data and unzips it.\n$ErrorActionPreference = 'Stop'\n\npushd $PSScriptRoot\n\necho \"Downl"
  },
  {
    "path": "data/mnist/get_mnist.sh",
    "chars": 408,
    "preview": "#!/usr/bin/env sh\n# This scripts downloads the mnist data and unzips it.\n\nDIR=\"$( cd \"$(dirname \"$0\")\" ; pwd -P )\"\ncd \"$"
  },
  {
    "path": "docker/README.md",
    "chars": 1509,
    "preview": "### Running an official image\n\nYou can run one of the automatic [builds](https://hub.docker.com/r/bvlc/caffe). E.g. for "
  },
  {
    "path": "docker/cpu/Dockerfile",
    "chars": 1349,
    "preview": "FROM ubuntu:16.04\nLABEL maintainer caffe-maint@googlegroups.com\n\nRUN apt-get update && apt-get install -y --no-install-r"
  },
  {
    "path": "docker/gpu/Dockerfile",
    "chars": 1499,
    "preview": "FROM nvidia/cuda:8.0-cudnn6-devel-ubuntu16.04\nLABEL maintainer caffe-maint@googlegroups.com\n\nRUN apt-get update && apt-g"
  },
  {
    "path": "docs/CMakeLists.txt",
    "chars": 4532,
    "preview": "# Building docs script\n# Requirements:\n#   sudo apt-get install doxygen texlive ruby-dev\n#   sudo gem install jekyll exe"
  },
  {
    "path": "docs/CNAME",
    "chars": 25,
    "preview": "caffe.berkeleyvision.org\n"
  },
  {
    "path": "docs/README.md",
    "chars": 241,
    "preview": "# Caffe Documentation\n\nTo generate the documentation, run `$CAFFE_ROOT/scripts/build_docs.sh`.\n\nTo push your changes to "
  },
  {
    "path": "docs/_config.yml",
    "chars": 131,
    "preview": "defaults:\n  -\n    scope:\n      path: \"\" # an empty string here means all files in the project\n    values:\n      layout: "
  },
  {
    "path": "docs/_layouts/default.html",
    "chars": 2058,
    "preview": "<!doctype html>\n<html>\n  <head>\n    <!-- MathJax -->\n    <script type=\"text/javascript\"\n      src=\"http://cdn.mathjax.or"
  },
  {
    "path": "docs/development.md",
    "chars": 6631,
    "preview": "---\ntitle: Developing and Contributing\n---\n# Development and Contributing\n\nCaffe is developed with active participation "
  },
  {
    "path": "docs/index.md",
    "chars": 6337,
    "preview": "---\ntitle: Deep Learning Framework\n---\n\n# Caffe\n\nCaffe is a deep learning framework made with expression, speed, and mod"
  },
  {
    "path": "docs/install_apt.md",
    "chars": 1987,
    "preview": "---\ntitle: \"Installation: Ubuntu\"\n---\n\n# Ubuntu Installation\n\n**General dependencies**\n\n    sudo apt-get install libprot"
  },
  {
    "path": "docs/install_apt_debian.md",
    "chars": 6124,
    "preview": "---\ntitle: \"Installation: Debian\"\n---\n\n# Debian Installation\n\nCaffe packages are available for several Debian versions, "
  },
  {
    "path": "docs/install_osx.md",
    "chars": 6318,
    "preview": "---\ntitle: \"Installation: OS X\"\n---\n\n# OS X Installation\n\nWe highly recommend using the [Homebrew](http://brew.sh/) pack"
  },
  {
    "path": "docs/install_yum.md",
    "chars": 1783,
    "preview": "---\ntitle: \"Installation: RHEL / Fedora / CentOS\"\n---\n\n# RHEL / Fedora / CentOS Installation\n\n**General dependencies**\n\n"
  },
  {
    "path": "docs/installation.md",
    "chars": 8398,
    "preview": "---\ntitle: Installation\n---\n\n# Installation\n\nPrior to installing, have a glance through this guide and take note of the "
  },
  {
    "path": "docs/model_zoo.md",
    "chars": 5044,
    "preview": "---\ntitle: Model Zoo\n---\n# Caffe Model Zoo\n\nLots of researchers and engineers have made Caffe models for different tasks"
  },
  {
    "path": "docs/multigpu.md",
    "chars": 2811,
    "preview": "---\ntitle: Multi-GPU Usage, Hardware Configuration Assumptions, and Performance\n---\n\n# Multi-GPU Usage\n\nCurrently Multi-"
  },
  {
    "path": "docs/stylesheets/pygment_trac.css",
    "chars": 4168,
    "preview": ".highlight  { background: #ffffff; }\n.highlight .c { color: #999988; font-style: italic } /* Comment */\n.highlight .err "
  },
  {
    "path": "docs/stylesheets/reset.css",
    "chars": 602,
    "preview": "/* MeyerWeb Reset */\n\nhtml, body, div, span, applet, object, iframe,\nh1, h2, h3, h4, h5, h6, p, blockquote, pre,\na, abbr"
  },
  {
    "path": "docs/stylesheets/styles.css",
    "chars": 4385,
    "preview": "@import url(http://fonts.googleapis.com/css?family=PT+Serif|Open+Sans:600,400);\n\nbody {\n  padding:10px 50px 0 0;\n  font-"
  },
  {
    "path": "docs/tutorial/convolution.md",
    "chars": 683,
    "preview": "---\ntitle: Convolution\n---\n# Caffeinated Convolution\n\nThe Caffe strategy for convolution is to reduce the problem to mat"
  },
  {
    "path": "docs/tutorial/data.md",
    "chars": 3496,
    "preview": "---\ntitle: Data\n---\n# Data: Ins and Outs\n\nData flows through Caffe as [Blobs](net_layer_blob.html#blob-storage-and-commu"
  },
  {
    "path": "docs/tutorial/fig/.gitignore",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "docs/tutorial/forward_backward.md",
    "chars": 2463,
    "preview": "---\ntitle: Forward and Backward for Inference and Learning\n---\n# Forward and Backward\n\nThe forward and backward passes a"
  },
  {
    "path": "docs/tutorial/index.md",
    "chars": 3219,
    "preview": "---\ntitle: Caffe Tutorial\n---\n# Caffe Tutorial\n\nCaffe is a deep learning framework and this tutorial explains its philos"
  },
  {
    "path": "docs/tutorial/interfaces.md",
    "chars": 14301,
    "preview": "---\ntitle: Interfaces\n---\n# Interfaces\n\nCaffe has command line, Python, and MATLAB interfaces for day-to-day usage, inte"
  },
  {
    "path": "docs/tutorial/layers/absval.md",
    "chars": 792,
    "preview": "---\ntitle: Absolute Value Layer\n---\n\n# Absolute Value Layer\n\n* Layer type: `AbsVal`\n* [Doxygen Documentation](http://caf"
  },
  {
    "path": "docs/tutorial/layers/accuracy.md",
    "chars": 864,
    "preview": "---\ntitle: Accuracy and Top-k\n---\n\n# Accuracy and Top-k\n\n`Accuracy` scores the output as the accuracy of output with res"
  },
  {
    "path": "docs/tutorial/layers/argmax.md",
    "chars": 700,
    "preview": "---\ntitle: ArgMax Layer\n---\n\n# ArgMax Layer\n\n* Layer type: `ArgMax`\n* [Doxygen Documentation](http://caffe.berkeleyvisio"
  },
  {
    "path": "docs/tutorial/layers/batchnorm.md",
    "chars": 890,
    "preview": "---\ntitle: Batch Norm Layer\n---\n\n# Batch Norm Layer\n\n* Layer type: `BatchNorm`\n* [Doxygen Documentation](http://caffe.be"
  },
  {
    "path": "docs/tutorial/layers/batchreindex.md",
    "chars": 682,
    "preview": "---\ntitle: Batch Reindex Layer\n---\n\n# Batch Reindex Layer\n\n* Layer type: `BatchReindex`\n* [Doxygen Documentation](http:/"
  },
  {
    "path": "docs/tutorial/layers/bias.md",
    "chars": 816,
    "preview": "---\ntitle: Bias Layer\n---\n\n# Bias Layer\n\n* Layer type: `Bias`\n* [Doxygen Documentation](http://caffe.berkeleyvision.org/"
  },
  {
    "path": "docs/tutorial/layers/bnll.md",
    "chars": 823,
    "preview": "---\ntitle: BNLL Layer\n---\n\n# BNLL Layer\n\n* Layer type: `BNLL`\n* [Doxygen Documentation](http://caffe.berkeleyvision.org/"
  },
  {
    "path": "docs/tutorial/layers/concat.md",
    "chars": 1520,
    "preview": "---\ntitle: Concat Layer\n---\n\n# Concat Layer\n\n* Layer type: `Concat`\n* [Doxygen Documentation](http://caffe.berkeleyvisio"
  },
  {
    "path": "docs/tutorial/layers/contrastiveloss.md",
    "chars": 969,
    "preview": "---\ntitle: Contrastive Loss Layer\n---\n\n# Contrastive Loss Layer\n\n* Layer type: `ContrastiveLoss`\n* [Doxygen Documentatio"
  },
  {
    "path": "docs/tutorial/layers/convolution.md",
    "chars": 3128,
    "preview": "---\ntitle: Convolution Layer\n---\n\n# Convolution Layer\n\n* Layer type: `Convolution`\n* [Doxygen Documentation](http://caff"
  },
  {
    "path": "docs/tutorial/layers/crop.md",
    "chars": 817,
    "preview": "---\ntitle: Crop Layer\n---\n\n# Crop Layer\n\n* Layer type: `Crop`\n* [Doxygen Documentation](http://caffe.berkeleyvision.org/"
  },
  {
    "path": "docs/tutorial/layers/data.md",
    "chars": 1058,
    "preview": "---\ntitle: Database Layer\n---\n\n# Database Layer\n\n* Layer type: `Data`\n* [Doxygen Documentation](http://caffe.berkeleyvis"
  },
  {
    "path": "docs/tutorial/layers/deconvolution.md",
    "chars": 938,
    "preview": "---\ntitle: Deconvolution Layer\n---\n\n# Deconvolution Layer\n\n* Layer type: `Deconvolution`\n* [Doxygen Documentation](http:"
  },
  {
    "path": "docs/tutorial/layers/dropout.md",
    "chars": 856,
    "preview": "---\ntitle: Dropout Layer\n---\n\n# Dropout Layer\n\n* Layer type: `Dropout`\n* [Doxygen Documentation](http://caffe.berkeleyvi"
  },
  {
    "path": "docs/tutorial/layers/dummydata.md",
    "chars": 742,
    "preview": "---\ntitle: Dummy Data Layer\n---\n\n# Dummy Data Layer\n\n* Layer type: `DummyData`\n* [Doxygen Documentation](http://caffe.be"
  },
  {
    "path": "docs/tutorial/layers/eltwise.md",
    "chars": 856,
    "preview": "---\ntitle: Eltwise Layer\n---\n\n# Eltwise Layer\n\n* Layer type: `Eltwise`\n* [Doxygen Documentation](http://caffe.berkeleyvi"
  },
  {
    "path": "docs/tutorial/layers/elu.md",
    "chars": 1024,
    "preview": "---\ntitle: ELU Layer\n---\n\n# ELU Layer\n\n* Layer type: `ELU`\n* [Doxygen Documentation](http://caffe.berkeleyvision.org/dox"
  },
  {
    "path": "docs/tutorial/layers/embed.md",
    "chars": 829,
    "preview": "---\ntitle: Embed Layer\n---\n\n# Embed Layer\n\n* Layer type: `Embed`\n* [Doxygen Documentation](http://caffe.berkeleyvision.o"
  },
  {
    "path": "docs/tutorial/layers/euclideanloss.md",
    "chars": 865,
    "preview": "---\ntitle: Euclidean Loss Layer\n---\n# Sum-of-Squares / Euclidean Loss Layer\n\n* Layer type: `EuclideanLoss`\n* [Doxygen Do"
  },
  {
    "path": "docs/tutorial/layers/exp.md",
    "chars": 858,
    "preview": "---\ntitle: Exponential Layer\n---\n\n# Exponential Layer\n\n* Layer type: `Exp`\n* [Doxygen Documentation](http://caffe.berkel"
  },
  {
    "path": "docs/tutorial/layers/filter.md",
    "chars": 628,
    "preview": "---\ntitle: Filter Layer\n---\n\n# Filter Layer\n\n* Layer type: `Filter`\n* [Doxygen Documentation](http://caffe.berkeleyvisio"
  },
  {
    "path": "docs/tutorial/layers/flatten.md",
    "chars": 849,
    "preview": "---\ntitle: Flatten Layer\n---\n\n# Flatten Layer\n\n* Layer type: `Flatten`\n* [Doxygen Documentation](http://caffe.berkeleyvi"
  },
  {
    "path": "docs/tutorial/layers/hdf5data.md",
    "chars": 877,
    "preview": "---\ntitle: HDF5 Data Layer\n---\n\n# HDF5 Data Layer\n\n* Layer type: `HDF5Data`\n* [Doxygen Documentation](http://caffe.berke"
  },
  {
    "path": "docs/tutorial/layers/hdf5output.md",
    "chars": 1093,
    "preview": "---\ntitle: HDF5 Output Layer\n---\n\n# HDF5 Output Layer\n\n* Layer type: `HDF5Output`\n* [Doxygen Documentation](http://caffe"
  },
  {
    "path": "docs/tutorial/layers/hingeloss.md",
    "chars": 749,
    "preview": "---\ntitle: Hinge Loss Layer\n---\n\n# Hinge (L1, L2) Loss Layer\n\n* Layer type: `HingeLoss`\n* [Doxygen Documentation](http:/"
  },
  {
    "path": "docs/tutorial/layers/im2col.md",
    "chars": 708,
    "preview": "---\ntitle: Im2col Layer\n---\n\n# im2col\n\n* File type: `Im2col`\n* Header: [`./include/caffe/layers/im2col_layer.hpp`](https"
  },
  {
    "path": "docs/tutorial/layers/imagedata.md",
    "chars": 1062,
    "preview": "---\ntitle: ImageData Layer\n---\n\n# ImageData Layer\n\n* Layer type: `ImageData`\n* [Doxygen Documentation](http://caffe.berk"
  },
  {
    "path": "docs/tutorial/layers/infogainloss.md",
    "chars": 1052,
    "preview": "---\ntitle: Infogain Loss Layer\n---\n\n# Infogain Loss Layer\n\n* Layer type: `InfogainLoss`\n* [Doxygen Documentation](http:/"
  },
  {
    "path": "docs/tutorial/layers/innerproduct.md",
    "chars": 2189,
    "preview": "---\ntitle: Inner Product / Fully Connected Layer\n---\n\n# Inner Product / Fully Connected Layer\n\n* Layer type: `InnerProdu"
  },
  {
    "path": "docs/tutorial/layers/input.md",
    "chars": 690,
    "preview": "---\ntitle: Input Layer\n---\n\n# Input Layer\n\n* Layer type: `Input`\n* [Doxygen Documentation](http://caffe.berkeleyvision.o"
  },
  {
    "path": "docs/tutorial/layers/lrn.md",
    "chars": 1993,
    "preview": "---\ntitle: Local Response Normalization (LRN)\n---\n\n# Local Response Normalization (LRN)\n\n* Layer type: `LRN`\n* [Doxygen "
  },
  {
    "path": "docs/tutorial/layers/lstm.md",
    "chars": 995,
    "preview": "---\ntitle: LSTM Layer\n---\n\n# LSTM Layer\n\n* Layer type: `LSTM`\n* [Doxygen Documentation](http://caffe.berkeleyvision.org/"
  },
  {
    "path": "docs/tutorial/layers/memorydata.md",
    "chars": 1193,
    "preview": "---\ntitle: Memory Data Layer\n---\n\n# Memory Data Layer\n\n* Layer type: `MemoryData`\n* [Doxygen Documentation](http://caffe"
  },
  {
    "path": "docs/tutorial/layers/multinomiallogisticloss.md",
    "chars": 842,
    "preview": "---\ntitle: Multinomial Logistic Loss Layer\n---\n\n# Multinomial Logistic Loss Layer\n\n* Layer type: `MultinomialLogisticLos"
  },
  {
    "path": "docs/tutorial/layers/mvn.md",
    "chars": 863,
    "preview": "---\ntitle: Mean-Variance Normalization (MVN) Layer\n---\n\n# Mean-Variance Normalization (MVN) Layer\n\n* Layer type: `MVN`\n*"
  },
  {
    "path": "docs/tutorial/layers/parameter.md",
    "chars": 822,
    "preview": "---\ntitle: Parameter Layer\n---\n\n# Parameter Layer\n\n* Layer type: `Parameter`\n* [Doxygen Documentation](http://caffe.berk"
  },
  {
    "path": "docs/tutorial/layers/pooling.md",
    "chars": 1947,
    "preview": "---\ntitle: Pooling Layer\n---\n# Pooling\n\n* Layer type: `Pooling`\n* [Doxygen Documentation](http://caffe.berkeleyvision.or"
  },
  {
    "path": "docs/tutorial/layers/power.md",
    "chars": 1288,
    "preview": "---\ntitle: Power Layer\n---\n\n# Power Layer\n\n* Layer type: `Power`\n* [Doxygen Documentation](http://caffe.berkeleyvision.o"
  },
  {
    "path": "docs/tutorial/layers/prelu.md",
    "chars": 829,
    "preview": "---\ntitle: PReLU Layer\n---\n\n# PReLU Layer\n\n* Layer type: `PReLU`\n* [Doxygen Documentation](http://caffe.berkeleyvision.o"
  },
  {
    "path": "docs/tutorial/layers/python.md",
    "chars": 1019,
    "preview": "---\ntitle: Python Layer\n---\n\n# Python Layer\n\n* Layer type: `Python`\n* [Doxygen Documentation](http://caffe.berkeleyvisio"
  },
  {
    "path": "docs/tutorial/layers/recurrent.md",
    "chars": 881,
    "preview": "---\ntitle: Recurrent Layer\n---\n\n# Recurrent Layer\n\n* Layer type: `Recurrent`\n* [Doxygen Documentation](http://caffe.berk"
  },
  {
    "path": "docs/tutorial/layers/reduction.md",
    "chars": 881,
    "preview": "---\ntitle: Reduction Layer\n---\n\n# Reduction Layer\n\n* Layer type: `Reduction`\n* [Doxygen Documentation](http://caffe.berk"
  },
  {
    "path": "docs/tutorial/layers/relu.md",
    "chars": 1687,
    "preview": "---\ntitle: ReLU / Rectified-Linear and Leaky-ReLU Layer\n---\n\n# ReLU / Rectified-Linear and Leaky-ReLU Layer\n\n* Layer typ"
  },
  {
    "path": "docs/tutorial/layers/reshape.md",
    "chars": 2376,
    "preview": "---\ntitle: Reshape Layer\n---\n\n# Reshape Layer\n* Layer type: `Reshape`\n* [Doxygen Documentation](http://caffe.berkeleyvis"
  },
  {
    "path": "docs/tutorial/layers/rnn.md",
    "chars": 685,
    "preview": "---\ntitle: RNN Layer\n---\n\n# RNN Layer\n\n* Layer type: `RNN`\n* [Doxygen Documentation](http://caffe.berkeleyvision.org/dox"
  },
  {
    "path": "docs/tutorial/layers/scale.md",
    "chars": 829,
    "preview": "---\ntitle: Scale Layer\n---\n\n# Scale Layer\n\n* Layer type: `Scale`\n* [Doxygen Documentation](http://caffe.berkeleyvision.o"
  },
  {
    "path": "docs/tutorial/layers/sigmoid.md",
    "chars": 1222,
    "preview": "---\ntitle: Sigmoid Layer\n---\n\n# Sigmoid Layer\n\n* Layer type: `Sigmoid`\n* [Doxygen Documentation](http://caffe.berkeleyvi"
  },
  {
    "path": "docs/tutorial/layers/sigmoidcrossentropyloss.md",
    "chars": 784,
    "preview": "---\ntitle: Sigmoid Cross-Entropy Loss Layer\n---\n\n# Sigmoid Cross-Entropy Loss Layer\n\n* Layer type: `SigmoidCrossEntropyL"
  },
  {
    "path": "docs/tutorial/layers/silence.md",
    "chars": 668,
    "preview": "---\ntitle: Silence Layer\n---\n\n# Silence Layer\n\n* Layer type: `Silence`\n* [Doxygen Documentation](http://caffe.berkeleyvi"
  },
  {
    "path": "docs/tutorial/layers/slice.md",
    "chars": 1501,
    "preview": "---\ntitle: Slice Layer\n---\n\n# Slice Layer\n\n* Layer type: `Slice`\n* [Doxygen Documentation](http://caffe.berkeleyvision.o"
  },
  {
    "path": "docs/tutorial/layers/softmax.md",
    "chars": 914,
    "preview": "---\ntitle: Softmax Layer\n---\n\n# Softmax Layer\n\n* Layer type: `Softmax`\n* [Doxygen Documentation](http://caffe.berkeleyvi"
  },
  {
    "path": "docs/tutorial/layers/softmaxwithloss.md",
    "chars": 1442,
    "preview": "---\ntitle: Softmax with Loss Layer\n---\n\n# Softmax with Loss Layer\n\n* Layer type: `SoftmaxWithLoss`\n* [Doxygen Documentat"
  },
  {
    "path": "docs/tutorial/layers/split.md",
    "chars": 769,
    "preview": "---\ntitle: Split Layer\n---\n\n# Split Layer\n\n* Layer type: `Split`\n* [Doxygen Documentation](http://caffe.berkeleyvision.o"
  },
  {
    "path": "docs/tutorial/layers/spp.md",
    "chars": 708,
    "preview": "---\ntitle: Spatial Pyramid Pooling Layer\n---\n\n# Spatial Pyramid Pooling Layer\n\n* Layer type: `SPP`\n* [Doxygen Documentat"
  },
  {
    "path": "docs/tutorial/layers/tanh.md",
    "chars": 699,
    "preview": "---\ntitle: TanH Layer\n---\n\n# TanH Layer\n\n* Header: [`./include/caffe/layers/tanh_layer.hpp`](https://github.com/BVLC/caf"
  },
  {
    "path": "docs/tutorial/layers/threshold.md",
    "chars": 754,
    "preview": "---\ntitle: Threshold Layer\n---\n\n# Threshold Layer\n\n* Header: [`./include/caffe/layers/threshold_layer.hpp`](https://gith"
  },
  {
    "path": "docs/tutorial/layers/tile.md",
    "chars": 816,
    "preview": "---\ntitle: Tile Layer\n---\n\n# Tile Layer\n\n* Layer type: `Tile`\n* [Doxygen Documentation](http://caffe.berkeleyvision.org/"
  },
  {
    "path": "docs/tutorial/layers/windowdata.md",
    "chars": 731,
    "preview": "---\ntitle: WindowData Layer\n---\n\n# WindowData Layer\n\n* Layer type: `WindowData`\n* [Doxygen Documentation](http://caffe.b"
  },
  {
    "path": "docs/tutorial/layers.md",
    "chars": 7237,
    "preview": "---\ntitle: Layer Catalogue\n---\n\n# Layers\n\nTo create a Caffe model you need to define the model architecture in a protoco"
  },
  {
    "path": "docs/tutorial/loss.md",
    "chars": 2783,
    "preview": "---\ntitle: Loss\n---\n# Loss\n\nIn Caffe, as in most of machine learning, learning is driven by a **loss** function (also kn"
  },
  {
    "path": "docs/tutorial/net_layer_blob.md",
    "chars": 13260,
    "preview": "---\ntitle: Blobs, Layers, and Nets\n---\n# Blobs, Layers, and Nets: anatomy of a Caffe model\n\nDeep networks are compositio"
  },
  {
    "path": "docs/tutorial/solver.md",
    "chars": 18227,
    "preview": "---\ntitle: Solver / Model Optimization\n---\n# Solver\n\nThe solver orchestrates model optimization by coordinating the netw"
  },
  {
    "path": "examples/00-classification.ipynb",
    "chars": 813348,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Classification: Instant Recogniti"
  },
  {
    "path": "examples/01-learning-lenet.ipynb",
    "chars": 376291,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Solving in Python with LeNet\\n\",\n"
  },
  {
    "path": "examples/02-fine-tuning.ipynb",
    "chars": 480504,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Fine-tuning a Pretrained Network "
  },
  {
    "path": "examples/CMakeLists.txt",
    "chars": 1278,
    "preview": "file(GLOB_RECURSE examples_srcs \"${PROJECT_SOURCE_DIR}/examples/*.cpp\")\n\nforeach(source_file ${examples_srcs})\n  # get f"
  },
  {
    "path": "examples/brewing-logreg.ipynb",
    "chars": 452886,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Brewing Logistic Regression then "
  },
  {
    "path": "examples/cifar10/cifar10_full.prototxt",
    "chars": 2174,
    "preview": "name: \"CIFAR10_full_deploy\"\n# N.B. input image must be in CIFAR-10 format\n# as described at http://www.cs.toronto.edu/~k"
  },
  {
    "path": "examples/cifar10/cifar10_full_sigmoid_solver.prototxt",
    "chars": 953,
    "preview": "# reduce learning rate after 120 epochs (60000 iters) by factor 0f 10\n# then another factor of 10 after 10 more epochs ("
  },
  {
    "path": "examples/cifar10/cifar10_full_sigmoid_solver_bn.prototxt",
    "chars": 959,
    "preview": "# reduce learning rate after 120 epochs (60000 iters) by factor 0f 10\n# then another factor of 10 after 10 more epochs ("
  },
  {
    "path": "examples/cifar10/cifar10_full_sigmoid_train_test.prototxt",
    "chars": 2879,
    "preview": "name: \"CIFAR10_full\"\nlayer {\n  name: \"cifar\"\n  type: \"Data\"\n  top: \"data\"\n  top: \"label\"\n  include {\n    phase: TRAIN\n  "
  },
  {
    "path": "examples/cifar10/cifar10_full_sigmoid_train_test_bn.prototxt",
    "chars": 3192,
    "preview": "name: \"CIFAR10_full\"\nlayer {\n  name: \"cifar\"\n  type: \"Data\"\n  top: \"data\"\n  top: \"label\"\n  include {\n    phase: TRAIN\n  "
  },
  {
    "path": "examples/cifar10/cifar10_full_solver.prototxt",
    "chars": 944,
    "preview": "# reduce learning rate after 120 epochs (60000 iters) by factor 0f 10\n# then another factor of 10 after 10 more epochs ("
  },
  {
    "path": "examples/cifar10/cifar10_full_solver_lr1.prototxt",
    "chars": 944,
    "preview": "# reduce learning rate after 120 epochs (60000 iters) by factor 0f 10\n# then another factor of 10 after 10 more epochs ("
  },
  {
    "path": "examples/cifar10/cifar10_full_solver_lr2.prototxt",
    "chars": 945,
    "preview": "# reduce learning rate after 120 epochs (60000 iters) by factor 0f 10\n# then another factor of 10 after 10 more epochs ("
  },
  {
    "path": "examples/cifar10/cifar10_full_train_test.prototxt",
    "chars": 3122,
    "preview": "name: \"CIFAR10_full\"\nlayer {\n  name: \"cifar\"\n  type: \"Data\"\n  top: \"data\"\n  top: \"label\"\n  include {\n    phase: TRAIN\n  "
  },
  {
    "path": "examples/cifar10/cifar10_quick.prototxt",
    "chars": 1921,
    "preview": "name: \"CIFAR10_quick_test\"\nlayer {\n  name: \"data\"\n  type: \"Input\"\n  top: \"data\"\n  input_param { shape: { dim: 1 dim: 3 d"
  },
  {
    "path": "examples/cifar10/cifar10_quick_solver.prototxt",
    "chars": 859,
    "preview": "# reduce the learning rate after 8 epochs (4000 iters) by a factor of 10\n\n# The train/test net protocol buffer definitio"
  },
  {
    "path": "examples/cifar10/cifar10_quick_solver_lr1.prototxt",
    "chars": 882,
    "preview": "# reduce the learning rate after 8 epochs (4000 iters) by a factor of 10\n\n# The train/test net protocol buffer definitio"
  },
  {
    "path": "examples/cifar10/cifar10_quick_train_test.prototxt",
    "chars": 3088,
    "preview": "name: \"CIFAR10_quick\"\nlayer {\n  name: \"cifar\"\n  type: \"Data\"\n  top: \"data\"\n  top: \"label\"\n  include {\n    phase: TRAIN\n "
  },
  {
    "path": "examples/cifar10/convert_cifar_data.cpp",
    "chars": 3677,
    "preview": "//\n// This script converts the CIFAR dataset to the leveldb format used\n// by caffe to perform classification.\n// Usage:"
  },
  {
    "path": "examples/cifar10/create_cifar10.sh",
    "chars": 467,
    "preview": "#!/usr/bin/env sh\n# This script converts the cifar data into leveldb format.\nset -e\n\nEXAMPLE=examples/cifar10\nDATA=data/"
  },
  {
    "path": "examples/cifar10/readme.md",
    "chars": 5243,
    "preview": "---\ntitle: CIFAR-10 tutorial\ncategory: example\ndescription: Train and test Caffe on CIFAR-10 data.\ninclude_in_docs: true"
  },
  {
    "path": "examples/cifar10/train_full.sh",
    "chars": 524,
    "preview": "#!/usr/bin/env sh\nset -e\n\nTOOLS=./build/tools\n\n$TOOLS/caffe train \\\n    --solver=examples/cifar10/cifar10_full_solver.pr"
  },
  {
    "path": "examples/cifar10/train_full_sigmoid.sh",
    "chars": 139,
    "preview": "#!/usr/bin/env sh\nset -e\n\nTOOLS=./build/tools\n\n$TOOLS/caffe train \\\n    --solver=examples/cifar10/cifar10_full_sigmoid_s"
  },
  {
    "path": "examples/cifar10/train_full_sigmoid_bn.sh",
    "chars": 142,
    "preview": "#!/usr/bin/env sh\nset -e\n\nTOOLS=./build/tools\n\n$TOOLS/caffe train \\\n    --solver=examples/cifar10/cifar10_full_sigmoid_s"
  },
  {
    "path": "examples/cifar10/train_quick.sh",
    "chars": 338,
    "preview": "#!/usr/bin/env sh\nset -e\n\nTOOLS=./build/tools\n\n$TOOLS/caffe train \\\n  --solver=examples/cifar10/cifar10_quick_solver.pro"
  },
  {
    "path": "examples/cpp_classification/classification.cpp",
    "chars": 8679,
    "preview": "#include <caffe/caffe.hpp>\n#ifdef USE_OPENCV\n#include <opencv2/core/core.hpp>\n#include <opencv2/highgui/highgui.hpp>\n#in"
  },
  {
    "path": "examples/cpp_classification/readme.md",
    "chars": 2837,
    "preview": "---\ntitle: CaffeNet C++ Classification example\ndescription: A simple example performing image classification using the l"
  },
  {
    "path": "examples/demo_darknet19.cmd",
    "chars": 804,
    "preview": "@echo off\n@setlocal EnableDelayedExpansion\nset detector=1\nset confidence_threshold=0.3\nset in_dir=data\\\nset wait_time=20"
  },
  {
    "path": "examples/demo_darknet19_voc.cmd",
    "chars": 812,
    "preview": "@echo off\n@setlocal EnableDelayedExpansion\nset detector=1\nset confidence_threshold=0.3\nset in_dir=data\\\nset wait_time=20"
  },
  {
    "path": "examples/demo_yolo.cmd",
    "chars": 821,
    "preview": "@echo off\n@setlocal EnableDelayedExpansion\nset detector=1\nset confidence_threshold=0.3\nset in_dir=data\\\nset wait_time=20"
  },
  {
    "path": "examples/demo_yolo_lite.cmd",
    "chars": 824,
    "preview": "@echo off\n@setlocal EnableDelayedExpansion\nset detector=1\nset confidence_threshold=0.3\nset in_dir=data\\\nset wait_time=10"
  },
  {
    "path": "examples/detection.ipynb",
    "chars": 702457,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"[R-CNN](https://github.com/rbgirshi"
  },
  {
    "path": "examples/feature_extraction/imagenet_val.prototxt",
    "chars": 3279,
    "preview": "name: \"CaffeNet\"\nlayer {\n  name: \"data\"\n  type: \"ImageData\"\n  top: \"data\"\n  top: \"label\"\n  transform_param {\n    mirror:"
  },
  {
    "path": "examples/feature_extraction/readme.md",
    "chars": 3087,
    "preview": "---\ntitle: Feature extraction with Caffe C++ code.\ndescription: Extract CaffeNet / AlexNet features using the Caffe util"
  },
  {
    "path": "examples/finetune_flickr_style/assemble_data.py",
    "chars": 3636,
    "preview": "#!/usr/bin/env python\n\"\"\"\nForm a subset of the Flickr Style data, download images to dirname, and write\nCaffe ImagesData"
  },
  {
    "path": "examples/finetune_flickr_style/readme.md",
    "chars": 10483,
    "preview": "---\ntitle: Fine-tuning for style recognition\ndescription: Fine-tune the ImageNet-trained CaffeNet on the \"Flickr Style\" "
  },
  {
    "path": "examples/finetune_flickr_style/style_names.txt",
    "chars": 173,
    "preview": "Detailed\nPastel\nMelancholy\nNoir\nHDR\nVintage\nLong Exposure\nHorror\nSunny\nBright\nHazy\nBokeh\nSerene\nTexture\nEthereal\nMacro\nD"
  },
  {
    "path": "examples/finetune_pascal_detection/pascal_finetune_solver.prototxt",
    "chars": 330,
    "preview": "net: \"examples/finetune_pascal_detection/pascal_finetune_trainval_test.prototxt\"\ntest_iter: 100\ntest_interval: 1000\nbase"
  },
  {
    "path": "examples/finetune_pascal_detection/pascal_finetune_trainval_test.prototxt",
    "chars": 5614,
    "preview": "name: \"CaffeNet\"\nlayer {\n  name: \"data\"\n  type: \"WindowData\"\n  top: \"data\"\n  top: \"label\"\n  include {\n    phase: TRAIN\n "
  },
  {
    "path": "examples/hdf5_classification/nonlinear_auto_test.prototxt",
    "chars": 782,
    "preview": "layer {\n  name: \"data\"\n  type: \"HDF5Data\"\n  top: \"data\"\n  top: \"label\"\n  hdf5_data_param {\n    source: \"examples/hdf5_cl"
  },
  {
    "path": "examples/hdf5_classification/nonlinear_auto_train.prototxt",
    "chars": 783,
    "preview": "layer {\n  name: \"data\"\n  type: \"HDF5Data\"\n  top: \"data\"\n  top: \"label\"\n  hdf5_data_param {\n    source: \"examples/hdf5_cl"
  },
  {
    "path": "examples/hdf5_classification/nonlinear_train_val.prototxt",
    "chars": 1395,
    "preview": "name: \"LogisticRegressionNet\"\nlayer {\n  name: \"data\"\n  type: \"HDF5Data\"\n  top: \"data\"\n  top: \"label\"\n  include {\n    pha"
  },
  {
    "path": "examples/hdf5_classification/train_val.prototxt",
    "chars": 999,
    "preview": "name: \"LogisticRegressionNet\"\nlayer {\n  name: \"data\"\n  type: \"HDF5Data\"\n  top: \"data\"\n  top: \"label\"\n  include {\n    pha"
  },
  {
    "path": "examples/imagenet/create_imagenet.sh",
    "chars": 1503,
    "preview": "#!/usr/bin/env sh\n# Create the imagenet lmdb inputs\n# N.B. set the path to the imagenet train + val data dirs\nset -e\n\nEX"
  },
  {
    "path": "examples/imagenet/make_imagenet_mean.sh",
    "chars": 287,
    "preview": "#!/usr/bin/env sh\n# Compute the mean image from the imagenet training lmdb\n# N.B. this is available in data/ilsvrc12\n\nEX"
  },
  {
    "path": "examples/imagenet/readme.md",
    "chars": 7634,
    "preview": "---\ntitle: ImageNet tutorial\ndescription: Train and test \"CaffeNet\" on ImageNet data.\ncategory: example\ninclude_in_docs:"
  },
  {
    "path": "examples/imagenet/resume_training.sh",
    "chars": 207,
    "preview": "#!/usr/bin/env sh\nset -e\n\n./build/tools/caffe train \\\n    --solver=models/bvlc_reference_caffenet/solver.prototxt \\\n    "
  },
  {
    "path": "examples/imagenet/train_caffenet.sh",
    "chars": 117,
    "preview": "#!/usr/bin/env sh\nset -e\n\n./build/tools/caffe train \\\n    --solver=models/bvlc_reference_caffenet/solver.prototxt $@\n"
  },
  {
    "path": "examples/mnist/convert_mnist_data.cpp",
    "chars": 4600,
    "preview": "// This script converts the MNIST dataset to a lmdb (default) or\n// leveldb (--backend=leveldb) format used by caffe to "
  },
  {
    "path": "examples/mnist/create_mnist.ps1",
    "chars": 949,
    "preview": "# This script converts the mnist data into lmdb/leveldb format,\n# depending on the value assigned to $BACKEND.\nparam(\n  "
  },
  {
    "path": "examples/mnist/create_mnist.sh",
    "chars": 634,
    "preview": "#!/usr/bin/env sh\n# This script converts the mnist data into lmdb/leveldb format,\n# depending on the value assigned to $"
  },
  {
    "path": "examples/mnist/lenet.prototxt",
    "chars": 1738,
    "preview": "name: \"LeNet\"\nlayer {\n  name: \"data\"\n  type: \"Input\"\n  top: \"data\"\n  input_param { shape: { dim: 64 dim: 1 dim: 28 dim: "
  },
  {
    "path": "examples/mnist/lenet_adadelta_solver.prototxt",
    "chars": 777,
    "preview": "# The train/test net protocol buffer definition\nnet: \"examples/mnist/lenet_train_test.prototxt\"\n# test_iter specifies ho"
  },
  {
    "path": "examples/mnist/lenet_auto_solver.prototxt",
    "chars": 778,
    "preview": "# The train/test net protocol buffer definition\ntrain_net: \"mnist/lenet_auto_train.prototxt\"\ntest_net: \"mnist/lenet_auto"
  },
  {
    "path": "examples/mnist/lenet_consolidated_solver.prototxt",
    "chars": 6003,
    "preview": "# lenet_consolidated_solver.prototxt consolidates the lenet_solver, lenet_train,\n# and lenet_test prototxts into a singl"
  },
  {
    "path": "examples/mnist/lenet_multistep_solver.prototxt",
    "chars": 871,
    "preview": "# The train/test net protocol buffer definition\nnet: \"examples/mnist/lenet_train_test.prototxt\"\n# test_iter specifies ho"
  },
  {
    "path": "examples/mnist/lenet_solver.prototxt",
    "chars": 790,
    "preview": "# The train/test net protocol buffer definition\nnet: \"examples/mnist/lenet_train_test.prototxt\"\n# test_iter specifies ho"
  },
  {
    "path": "examples/mnist/lenet_solver_adam.prototxt",
    "chars": 886,
    "preview": "# The train/test net protocol buffer definition\n# this follows \"ADAM: A METHOD FOR STOCHASTIC OPTIMIZATION\"\nnet: \"exampl"
  },
  {
    "path": "examples/mnist/lenet_solver_rmsprop.prototxt",
    "chars": 830,
    "preview": "# The train/test net protocol buffer definition\nnet: \"examples/mnist/lenet_train_test.prototxt\"\n# test_iter specifies ho"
  }
]

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