[ { "path": ".gitattributes", "content": "*.ipynb linguist-documentation\n" }, { "path": ".github/CONTRIBUTING.md", "content": "" }, { "path": ".github/ISSUE_TEMPLATE.md", "content": "If this is a build issue, please fill out the template below.\n\n### System information\n\n* Operating system:\n* Compiler version:\n* CMake version:\n* CMake arguments:\n* Relevant libraries/versions (e.g. CUDA):\n\n### CMake summary output\n\n```\n******** Summary ********\n\n```\n" }, { "path": ".github/PULL_REQUEST_TEMPLATE.md", "content": "" }, { "path": ".gitignore", "content": "## 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# Compiled Static libraries\n*.lai\n*.la\n*.a\n*.lib\n\n# Compiled protocol buffers\n*.pb.h\n*.pb.cc\n*_pb2.py\n\n# Compiled python\n*.pyc\n*.pyd\n\n# Compiled MATLAB\n*.mex*\n\n# IPython notebook checkpoints\n.ipynb_checkpoints\n\n# Editor temporaries\n*.swn\n*.swo\n*.swp\n*~\n\n# Sublime Text settings\n*.sublime-workspace\n*.sublime-project\n\n# Eclipse Project settings\n*.*project\n.settings\n\n# QtCreator files\n*.user\n\n# PyCharm files\n.idea\n\n# Visual Studio Code files\n.vscode\n.vs\n\n# OSX dir files\n.DS_Store\n\n## Caffe2\n\n# build, distribute, and bins (+ python proto bindings)\nbuild\nbuild_host_protoc\nbuild_android\nbuild_ios\nbuild_*\n.build_debug/*\n.build_release/*\ndistribute/*\n*.testbin\n*.bin\ncmake_build\n.cmake_build\ngen\n.setuptools-cmake-build\n.pytest_cache\n\n# Bram\nplsdontbreak\n\n# Generated documentation\ndocs/_site\ndocs/gathered\n_site\ndoxygen\ndocs/dev\n\n# LevelDB files\n*.sst\n*.ldb\nLOCK\nLOG*\nCURRENT\nMANIFEST-*\n\n# generated version file\ncaffe2/version.py\n\n# setup.py intermediates\n.eggs\ncaffe2.egg-info\n\n# Atom/Watchman required file\n.watchmanconfig\n" }, { "path": ".gitmodules", "content": "[submodule \"third_party/pybind11\"]\n\tpath = third_party/pybind11\n\turl = https://github.com/pybind/pybind11.git\n[submodule \"third_party/nccl\"]\n\tpath = third_party/nccl\n\turl = https://github.com/nvidia/nccl.git\n[submodule \"third_party/cub\"]\n\tpath = third_party/cub\n\turl = https://github.com/NVlabs/cub.git\n[submodule \"third_party/eigen\"]\n\tpath = third_party/eigen\n\turl = https://github.com/RLovelett/eigen.git\n[submodule \"third_party/googletest\"]\n\tpath = third_party/googletest\n\turl = https://github.com/google/googletest.git\n[submodule \"third_party/nervanagpu\"]\n\tpath = third_party/nervanagpu\n\turl = https://github.com/NervanaSystems/nervanagpu.git\n[submodule \"third_party/benchmark\"]\n\tpath = third_party/benchmark\n\turl = https://github.com/google/benchmark.git\n[submodule \"third_party/protobuf\"]\n\tpath = third_party/protobuf\n\turl = https://github.com/google/protobuf.git\n[submodule \"third_party/ios-cmake\"]\n\tpath = third_party/ios-cmake\n\turl = https://github.com/Yangqing/ios-cmake.git\n[submodule \"third_party/NNPACK\"]\n\tpath = third_party/NNPACK\n\turl = https://github.com/Maratyszcza/NNPACK.git\n[submodule \"third_party/gloo\"]\n\tpath = third_party/gloo\n\turl = https://github.com/facebookincubator/gloo\n[submodule \"third_party/NNPACK_deps/pthreadpool\"]\n\tpath = third_party/pthreadpool\n\turl = https://github.com/Maratyszcza/pthreadpool.git\n[submodule \"third_party/NNPACK_deps/FXdiv\"]\n\tpath = third_party/FXdiv\n\turl = https://github.com/Maratyszcza/FXdiv.git\n[submodule \"third_party/NNPACK_deps/FP16\"]\n\tpath = third_party/FP16\n\turl = https://github.com/Maratyszcza/FP16.git\n[submodule \"third_party/NNPACK_deps/psimd\"]\n\tpath = third_party/psimd\n\turl = https://github.com/Maratyszcza/psimd.git\n[submodule \"third_party/aten\"]\n\tpath = third_party/aten\n\turl = https://github.com/zdevito/aten\n[submodule \"third_party/zstd\"]\n\tpath = third_party/zstd\n\turl = https://github.com/facebook/zstd.git\n[submodule \"third-party/cpuinfo\"]\n\tpath = third_party/cpuinfo\n\turl = https://github.com/Maratyszcza/cpuinfo.git\n[submodule \"third_party/python-enum\"]\n\tpath = third_party/python-enum\n\turl = https://github.com/PeachPy/enum34.git\n[submodule \"third_party/python-peachpy\"]\n\tpath = third_party/python-peachpy\n\turl = https://github.com/Maratyszcza/PeachPy.git\n[submodule \"third_party/python-six\"]\n\tpath = third_party/python-six\n\turl = https://github.com/benjaminp/six.git\n[submodule \"third_party/ComputeLibrary\"]\n\tpath = third_party/ComputeLibrary\n\turl = https://github.com/ARM-software/ComputeLibrary.git\n[submodule \"third_party/onnx\"]\n\tpath = third_party/onnx\n\turl = https://github.com/onnx/onnx.git\n" }, { "path": ".jenkins/README.md", "content": "# Jenkins\n\nThe scripts in this directory are the entrypoint for testing Caffe2.\n\nThe environment variable `BUILD_ENVIRONMENT` is expected to be set to\nthe build environment you intend to test. It is a hint for the build\nand test scripts to configure Caffe2 a certain way and include/exclude\ntests. Docker images, they equal the name of the image itself. For\nexample: `py2-cuda9.0-cudnn7-ubuntu16.04`. The Docker images that are\nbuilt on Jenkins and are used in triggered builds already have this\nenvironment variable set in their manifest. Also see\n`./docker/jenkins/*/Dockerfile` and search for `BUILD_ENVIRONMENT`.\n\nOur Jenkins installation is located at https://ci.pytorch.org/jenkins/.\n" }, { "path": ".jenkins/build.sh", "content": "#!/bin/bash\n\nset -ex\n\nLOCAL_DIR=$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\nROOT_DIR=$(cd \"$LOCAL_DIR\"/.. && pwd)\n\n# Setup sccache if SCCACHE_BUCKET is set\nif [ -n \"${SCCACHE_BUCKET}\" ]; then\n mkdir -p ./sccache\n\n SCCACHE=\"$(which sccache)\"\n if [ -z \"${SCCACHE}\" ]; then\n echo \"Unable to find sccache...\"\n exit 1\n fi\n\n # Setup wrapper scripts\n for compiler in cc c++ gcc g++ x86_64-linux-gnu-gcc; do\n (\n echo \"#!/bin/sh\"\n echo \"exec $SCCACHE $(which $compiler) \\\"\\$@\\\"\"\n ) > \"./sccache/$compiler\"\n chmod +x \"./sccache/$compiler\"\n done\n\n # CMake must find these wrapper scripts\n export PATH=\"$PWD/sccache:$PATH\"\nfi\n\n# Setup ccache if configured to use it (and not sccache)\nif [ -z \"${SCCACHE}\" ] && which ccache > /dev/null; then\n mkdir -p ./ccache\n ln -sf \"$(which ccache)\" ./ccache/cc\n ln -sf \"$(which ccache)\" ./ccache/c++\n ln -sf \"$(which ccache)\" ./ccache/gcc\n ln -sf \"$(which ccache)\" ./ccache/g++\n ln -sf \"$(which ccache)\" ./ccache/x86_64-linux-gnu-gcc\n export CCACHE_WRAPPER_DIR=\"$PWD/ccache\"\n export PATH=\"$CCACHE_WRAPPER_DIR:$PATH\"\nfi\n\nCMAKE_ARGS=(\"-DBUILD_BINARY=ON\")\nCMAKE_ARGS+=(\"-DUSE_OBSERVERS=ON\")\nCMAKE_ARGS+=(\"-DUSE_ZSTD=ON\")\n\n# Run build script from scripts if applicable\nif [[ \"${BUILD_ENVIRONMENT}\" == *-android* ]]; then\n export ANDROID_NDK=/opt/ndk\n \"${ROOT_DIR}/scripts/build_android.sh\" ${CMAKE_ARGS[*]} \"$@\"\n exit 0\nfi\nif [[ \"${BUILD_ENVIRONMENT}\" == conda* ]]; then\n\n # click (required by onnx) wants these set\n export LANG=C.UTF-8\n export LC_ALL=C.UTF-8\n\n # SKIP_CONDA_TESTS refers to only the 'test' section of the meta.yaml\n export SKIP_CONDA_TESTS=1\n export CONDA_INSTALL_LOCALLY=1\n \"${ROOT_DIR}/scripts/build_anaconda.sh\" \"$@\"\n\n # The tests all need hypothesis, tabulate, and pydot, which aren't included\n # in the conda packages\n conda install -y hypothesis tabulate pydot\n\n # This build will be tested against onnx tests, which needs onnx installed.\n # Onnx should be built against the same protobuf that Caffe2 uses, which is\n # only installed in the conda environment when Caffe2 is.\n # This path comes from install_anaconda.sh which installs Anaconda into the\n # docker image\n PROTOBUF_INCDIR=/opt/conda/include pip install \"${ROOT_DIR}/third_party/onnx\"\n exit 0\nfi\n\n# Run cmake from ./build directory\nmkdir -p ./build\ncd ./build\n\nINSTALL_PREFIX=\"/usr/local/caffe2\"\nCMAKE_ARGS+=(\"-DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}\")\n\n# Explicitly set Python executable.\n# On Ubuntu 16.04 the default Python is still 2.7.\nPYTHON=\"$(which python)\"\nif [[ \"${BUILD_ENVIRONMENT}\" == py3* ]]; then\n PYTHON=/usr/bin/python3\n CMAKE_ARGS+=(\"-DPYTHON_EXECUTABLE=${PYTHON}\")\nfi\n\ncase \"${BUILD_ENVIRONMENT}\" in\n *-mkl*)\n CMAKE_ARGS+=(\"-DBLAS=MKL\")\n ;;\n *-cuda*)\n CMAKE_ARGS+=(\"-DUSE_CUDA=ON\")\n CMAKE_ARGS+=(\"-DCUDA_ARCH_NAME=Maxwell\")\n CMAKE_ARGS+=(\"-DUSE_NNPACK=OFF\")\n\n # Add ccache symlink for nvcc\n ln -sf \"$(which ccache)\" \"${CCACHE_WRAPPER_DIR}/nvcc\"\n\n # Explicitly set path to NVCC such that the symlink to ccache is used\n CMAKE_ARGS+=(\"-DCUDA_NVCC_EXECUTABLE=${CCACHE_WRAPPER_DIR}/nvcc\")\n\n # Ensure FindCUDA.cmake can infer the right path to the CUDA toolkit.\n # Setting PATH to resolve to the right nvcc alone isn't enough.\n # See /usr/share/cmake-3.5/Modules/FindCUDA.cmake, block at line 589.\n export CUDA_PATH=\"/usr/local/cuda\"\n\n # Ensure the ccache symlink can still find the real nvcc binary.\n export PATH=\"/usr/local/cuda/bin:$PATH\"\n ;;\nesac\n\n# Try to include Redis support for Linux builds\nif [ \"$(uname)\" == \"Linux\" ]; then\n CMAKE_ARGS+=(\"-DUSE_REDIS=ON\")\nfi\n\n# Currently, on Jenkins mac os, we will use custom protobuf. Mac OS\n# contbuild at the moment is minimal dependency - it doesn't use glog\n# or gflags either.\nif [ \"$(uname)\" == \"Darwin\" ]; then\n CMAKE_ARGS+=(\"-DBUILD_CUSTOM_PROTOBUF=ON\")\nfi\n\n# We test the presence of cmake3 (for platforms like Centos and Ubuntu 14.04)\n# and use that if so.\nif [[ -x \"$(command -v cmake3)\" ]]; then\n CMAKE_BINARY=cmake3\nelse\n CMAKE_BINARY=cmake\nfi\n\n# Configure\n${CMAKE_BINARY} \"${ROOT_DIR}\" ${CMAKE_ARGS[*]} \"$@\"\n\n# Build\nif [ \"$(uname)\" == \"Linux\" ]; then\n make \"-j$(nproc)\" install\nelse\n echo \"Don't know how to build on $(uname)\"\n exit 1\nfi\n\n# Install ONNX into a local directory\nONNX_INSTALL_PATH=\"/usr/local/onnx\"\npip install \"${ROOT_DIR}/third_party/onnx\" -t \"${ONNX_INSTALL_PATH}\"\n\n# Symlink the caffe2 base python path into the system python path,\n# so that we can import caffe2 without having to change $PYTHONPATH.\n# Run in a subshell to contain environment set by /etc/os-release.\n#\n# This is only done when running on Jenkins! We don't want to pollute\n# the user environment with Python symlinks and ld.so.conf.d hacks.\n#\nif [ -n \"${JENKINS_URL}\" ]; then\n (\n source /etc/os-release\n\n function python_version() {\n \"$PYTHON\" -c 'import sys; print(\"python%d.%d\" % sys.version_info[0:2])'\n }\n\n # Debian/Ubuntu\n if [[ \"$ID_LIKE\" == *debian* ]]; then\n python_path=\"/usr/local/lib/$(python_version)/dist-packages\"\n sudo ln -sf \"${INSTALL_PREFIX}/caffe2\" \"${python_path}\"\n sudo ln -sf \"${ONNX_INSTALL_PATH}/onnx\" \"${python_path}\"\n fi\n\n # RHEL/CentOS\n if [[ \"$ID_LIKE\" == *rhel* ]]; then\n python_path=\"/usr/lib64/$(python_version)/site-packages/\"\n sudo ln -sf \"${INSTALL_PREFIX}/caffe2\" \"${python_path}\"\n sudo ln -sf \"${ONNX_INSTALL_PATH}/onnx\" \"${python_path}\"\n fi\n\n # /etc/ld.so.conf.d is used on both Debian and RHEL\n echo \"${INSTALL_PREFIX}/lib\" | sudo tee /etc/ld.so.conf.d/caffe2.conf\n sudo ldconfig\n )\nfi\n" }, { "path": ".jenkins/test.sh", "content": "#!/bin/bash\n\nset -ex\n\n# Figure out which Python to use\nPYTHON=\"python\"\nif [ -n \"$BUILD_ENVIRONMENT\" ]; then\n if [[ \"$BUILD_ENVIRONMENT\" == py2* ]]; then\n PYTHON=\"python2\"\n elif [[ \"$BUILD_ENVIRONMENT\" == py3* ]]; then\n PYTHON=\"python3\"\n fi\nfi\n\n# The prefix must mirror the setting from build.sh\nINSTALL_PREFIX=\"/usr/local/caffe2\"\n\n# Anaconda builds have a special install prefix and python\nif [[ \"$BUILD_ENVIRONMENT\" == conda* ]]; then\n # This path comes from install_anaconda.sh which installs Anaconda into the\n # docker image\n PYTHON=\"/opt/conda/bin/python\"\n INSTALL_PREFIX=\"/opt/conda/\"\nfi\n\n# Add the site-packages in the caffe2 install prefix to the PYTHONPATH\nSITE_DIR=$($PYTHON -c \"from distutils import sysconfig; print(sysconfig.get_python_lib(prefix=''))\")\nINSTALL_SITE_DIR=\"${INSTALL_PREFIX}/${SITE_DIR}\"\n\nLOCAL_DIR=$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\nROOT_DIR=$(cd \"$LOCAL_DIR\"/.. && pwd)\n\n# Skip tests in environments where they are not built/applicable\nif [[ \"${BUILD_ENVIRONMENT}\" == *-android* ]]; then\n echo 'Skipping tests'\n exit 0\nfi\n\n# Set PYTHONPATH and LD_LIBRARY_PATH so that python can find the installed\n# Caffe2. This shouldn't be done on Anaconda, as Anaconda should handle this.\nif [[ \"$BUILD_ENVIRONMENT\" != conda* ]]; then\n export PYTHONPATH=\"${PYTHONPATH}:$INSTALL_SITE_DIR\"\n export LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:${INSTALL_PREFIX}/lib\"\nfi\n\nexit_code=0\n\ncd \"$ROOT_DIR\"/caffe2/python/tutorials\npython tutorials_to_script_converter.py\ngit status\nif git diff --quiet HEAD; then\n echo \"Source tree is clean.\"\nelse\n echo \"After running a tutorial -> script sync there are changes. This probably means you edited an ipython notebook without a proper sync to a script. Please see caffe2/python/tutorials/README.md for more information\"\n if [ \"$exit_code\" -eq 0 ]; then\n exit_code=1\n fi\nfi\n\ncd \"$ROOT_DIR\"\n\nif [ -d ./test ]; then\n echo \"Directory ./test already exists; please remove it...\"\n exit 1\nfi\n\nmkdir -p ./test/{cpp,python}\nTEST_DIR=\"$PWD/test\"\n\ncd ${INSTALL_PREFIX}\n\n# Commands below may exit with non-zero status\nset +e\n\n# C++ tests\necho \"Running C++ tests..\"\nfor test in ./test/*; do\n # Skip tests we know are hanging or bad\n case \"$(basename \"$test\")\" in\n mkl_utils_test)\n continue\n ;;\n # TODO investigate conv_op_test failures when using MKL\n conv_op_test)\n continue\n ;;\n esac\n\n \"$test\" --gtest_output=xml:\"$TEST_DIR\"/cpp/$(basename \"$test\").xml\n tmp_exit_code=\"$?\"\n if [ \"$exit_code\" -eq 0 ]; then\n exit_code=\"$tmp_exit_code\"\n fi\ndone\n\n# Get the relative path to where the caffe2 python module was installed\nCAFFE2_PYPATH=\"$INSTALL_SITE_DIR/caffe2\"\n\n# Collect additional tests to run (outside caffe2/python)\nEXTRA_TESTS=()\n\n# CUDA builds always include NCCL support\nif [[ \"$BUILD_ENVIRONMENT\" == *-cuda* ]]; then\n EXTRA_TESTS+=(\"$CAFFE2_PYPATH/contrib/nccl\")\nfi\n\n# Python tests\necho \"Running Python tests..\"\n\"$PYTHON\" \\\n -m pytest \\\n -x \\\n -v \\\n --junit-xml=\"$TEST_DIR/python/result.xml\" \\\n --ignore \"$CAFFE2_PYPATH/python/test/executor_test.py\" \\\n --ignore \"$CAFFE2_PYPATH/python/operator_test/matmul_op_test.py\" \\\n --ignore \"$CAFFE2_PYPATH/python/operator_test/pack_ops_test.py\" \\\n --ignore \"$CAFFE2_PYPATH/python/mkl/mkl_sbn_speed_test.py\" \\\n \"$CAFFE2_PYPATH/python\" \\\n \"${EXTRA_TESTS[@]}\"\n\ntmp_exit_code=\"$?\"\nif [ \"$exit_code\" -eq 0 ]; then\n exit_code=\"$tmp_exit_code\"\nfi\n\n# Exit with the first non-zero status we got\nexit \"$exit_code\"\n" }, { "path": ".travis/build.sh", "content": "#!/bin/bash\nset -e\nset -x\n\nLOCAL_DIR=$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\nROOT_DIR=$(dirname \"$LOCAL_DIR\")\ncd \"$ROOT_DIR\"\n\nmkdir build\ncd build\n\n# Special cases - run script and exit\nif [ \"$BUILD_ANDROID\" = 'true' ]; then\n export ANDROID_NDK=/opt/android_ndk\n \"${ROOT_DIR}/scripts/build_android.sh\"\n exit 0\nfi\nif [ \"$BUILD_IOS\" = 'true' ]; then\n \"${ROOT_DIR}/scripts/build_ios.sh\" -DCMAKE_OSX_ARCHITECTURES=arm64\n exit 0\nfi\n\n# Configure\nCMAKE_ARGS=('-DCMAKE_VERBOSE_MAKEFILE=ON')\nCMAKE_ARGS+=('-DCMAKE_INSTALL_PREFIX=../install')\nif [ \"$BUILD_CUDA\" = 'true' ]; then\n CMAKE_ARGS+=('-DUSE_CUDA=ON')\n CMAKE_ARGS+=('-DCUDA_ARCH_NAME=Pascal')\n CMAKE_ARGS+=('-DCUDA_NVCC_EXECUTABLE=/usr/local/bin/nvcc')\n export PATH=\"/usr/local/cuda/bin:${PATH}\"\n CMAKE_ARGS+=('-DUSE_NNPACK=OFF')\nelse\n CMAKE_ARGS+=('-DUSE_CUDA=OFF')\nfi\nif [ \"$BUILD_MKL\" = 'true' ]; then\n CMAKE_ARGS+=('-DBLAS=MKL')\nfi\nif [ \"$BUILD_TESTS\" = 'false' ]; then\n CMAKE_ARGS+=('-DBUILD_TEST=OFF')\nfi\nCMAKE_ARGS+=$(python $ROOT_DIR/scripts/get_python_cmake_flags.py)\ncmake .. ${CMAKE_ARGS[*]}\n\n# Build\nif [ \"$TRAVIS_OS_NAME\" = 'linux' ]; then\n make \"-j$(nproc)\" install\nelif [ \"$TRAVIS_OS_NAME\" = 'osx' ]; then\n make \"-j$(sysctl -n hw.ncpu)\" install\nfi\n" }, { "path": ".travis/install.sh", "content": "#!/bin/bash\nset -e\nset -x\n\nLOCAL_DIR=$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\nROOT_DIR=$(dirname \"$LOCAL_DIR\")\ncd \"$ROOT_DIR\"\n\nAPT_INSTALL_CMD='sudo apt-get install -y --no-install-recommends'\n\nif [ \"$TRAVIS_OS_NAME\" = 'linux' ]; then\n ####################\n # apt dependencies #\n ####################\n sudo apt-get update\n $APT_INSTALL_CMD \\\n asciidoc \\\n autoconf \\\n automake \\\n build-essential \\\n ca-certificates \\\n ccache \\\n docbook-xml \\\n docbook-xsl \\\n git \\\n gperf \\\n libatlas-base-dev \\\n libgoogle-glog-dev \\\n libiomp-dev \\\n libleveldb-dev \\\n liblmdb-dev \\\n libopencv-dev \\\n libprotobuf-dev \\\n libpthread-stubs0-dev \\\n libsnappy-dev \\\n protobuf-compiler \\\n python \\\n python-dev \\\n python-pip \\\n python-wheel \\\n software-properties-common \\\n xsltproc\n\n # Install ccache symlink wrappers\n pushd /usr/local/bin\n sudo ln -sf \"$(which ccache)\" gcc\n sudo ln -sf \"$(which ccache)\" g++\n popd\n\n if [ \"$BUILD_GCC5\" = 'true' ]; then\n ################\n # Install GCC5 #\n ################\n sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test\n sudo apt-get update\n $APT_INSTALL_CMD g++-5\n sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 60 \\\n --slave /usr/bin/g++ g++ /usr/bin/g++-5\n fi\n\n if [ \"$BUILD_CUDA\" = 'true' ]; then\n ##################\n # Install ccache #\n ##################\n # Needs specific branch to work with nvcc (ccache/ccache#145)\n if [ -e \"${BUILD_CCACHE_DIR}/ccache\" ]; then\n echo \"Using cached ccache build at \\\"$BUILD_CCACHE_DIR\\\" ...\"\n else\n git clone https://github.com/colesbury/ccache -b ccbin \"$BUILD_CCACHE_DIR\"\n pushd \"$BUILD_CCACHE_DIR\"\n ./autogen.sh\n ./configure\n make \"-j$(nproc)\"\n popd\n fi\n\n # Overwrite ccache symlink wrappers\n pushd /usr/local/bin\n sudo ln -sf \"${BUILD_CCACHE_DIR}/ccache\" gcc\n sudo ln -sf \"${BUILD_CCACHE_DIR}/ccache\" g++\n sudo ln -sf \"${BUILD_CCACHE_DIR}/ccache\" nvcc\n popd\n\n #################\n # Install CMake #\n #################\n # Newer version required to get cmake+ccache+nvcc to work\n _cmake_installer=/tmp/cmake.sh\n wget -O \"$_cmake_installer\" https://cmake.org/files/v3.8/cmake-3.8.2-Linux-x86_64.sh\n sudo bash \"$_cmake_installer\" --prefix=/usr/local --skip-license\n rm -rf \"$_cmake_installer\"\n\n ################\n # Install CUDA #\n ################\n CUDA_REPO_PKG='cuda-repo-ubuntu1404_8.0.44-1_amd64.deb'\n CUDA_PKG_VERSION='8-0'\n CUDA_VERSION='8.0'\n wget \"https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1404/x86_64/${CUDA_REPO_PKG}\"\n sudo dpkg -i \"$CUDA_REPO_PKG\"\n rm -f \"$CUDA_REPO_PKG\"\n sudo apt-get update\n $APT_INSTALL_CMD \\\n \"cuda-core-${CUDA_PKG_VERSION}\" \\\n \"cuda-cublas-dev-${CUDA_PKG_VERSION}\" \\\n \"cuda-cudart-dev-${CUDA_PKG_VERSION}\" \\\n \"cuda-curand-dev-${CUDA_PKG_VERSION}\" \\\n \"cuda-driver-dev-${CUDA_PKG_VERSION}\" \\\n \"cuda-nvrtc-dev-${CUDA_PKG_VERSION}\"\n # Manually create CUDA symlink\n sudo ln -sf /usr/local/cuda-$CUDA_VERSION /usr/local/cuda\n\n #################\n # Install cuDNN #\n #################\n CUDNN_REPO_PKG='nvidia-machine-learning-repo-ubuntu1404_4.0-2_amd64.deb'\n CUDNN_PKG_VERSION='6.0.20-1+cuda8.0'\n wget \"https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1404/x86_64/${CUDNN_REPO_PKG}\"\n sudo dpkg -i \"$CUDNN_REPO_PKG\"\n rm -f \"$CUDNN_REPO_PKG\"\n sudo apt-get update\n $APT_INSTALL_CMD \\\n \"libcudnn6=${CUDNN_PKG_VERSION}\" \\\n \"libcudnn6-dev=${CUDNN_PKG_VERSION}\"\n fi\n\n if [ \"$BUILD_MKL\" = 'true' ]; then\n ###############\n # Install MKL #\n ###############\n _mkl_key=/tmp/mkl.pub\n wget -O \"$_mkl_key\" http://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB\n sudo apt-key add \"$_mkl_key\"\n rm -f \"$_mkl_key\"\n echo 'deb http://apt.repos.intel.com/mkl all main' | sudo tee /etc/apt/sources.list.d/intel-mkl.list\n sudo apt-get update\n $APT_INSTALL_CMD intel-mkl-64bit\n fi\nelif [ \"$TRAVIS_OS_NAME\" = 'osx' ]; then\n #####################\n # brew dependencies #\n #####################\n brew update\n brew install python\n pip uninstall -y numpy # use brew version (opencv dependency)\n brew tap homebrew/science # for OpenCV\n brew install \\\n ccache \\\n glog \\\n leveldb \\\n lmdb \\\n protobuf\n\n # Install ccache symlink wrappers\n pushd /usr/local/bin\n sudo ln -sf \"$(which ccache)\" clang\n sudo ln -sf \"$(which ccache)\" clang++\n popd\nelse\n echo \"OS \\\"$TRAVIS_OS_NAME\\\" is unknown\"\n exit 1\nfi\n\n####################\n# pip dependencies #\n####################\nsudo pip install \\\n future \\\n hypothesis \\\n numpy \\\n protobuf \\\n pytest \\\n scikit-image\n\nif [ \"$BUILD_ANDROID\" = 'true' ]; then\n #######################\n # Install Android NDK #\n #######################\n _ndk_zip=/tmp/ndk.zip\n if [ \"$TRAVIS_OS_NAME\" = 'linux' ]; then\n $APT_INSTALL_CMD autotools-dev autoconf\n wget -O \"$_ndk_zip\" https://dl.google.com/android/repository/android-ndk-r13b-linux-x86_64.zip\n elif [ \"$TRAVIS_OS_NAME\" = 'osx' ]; then\n brew install libtool\n wget -O \"$_ndk_zip\" https://dl.google.com/android/repository/android-ndk-r13b-darwin-x86_64.zip\n else\n echo \"OS \\\"$TRAVIS_OS_NAME\\\" is unknown\"\n exit 1\n fi\n _ndk_dir=/opt/android_ndk\n sudo mkdir -p \"$_ndk_dir\"\n sudo chmod a+rwx \"$_ndk_dir\"\n unzip -qo \"$_ndk_zip\" -d \"$_ndk_dir\"\n rm -f \"$_ndk_zip\"\n _versioned_dir=$(find $_ndk_dir/ -mindepth 1 -maxdepth 1 -type d)\n mv \"$_versioned_dir\"/* \"$_ndk_dir\"/\n rmdir \"$_versioned_dir\"\nfi\n\nif [ \"$BUILD_NNPACK\" = 'true' ]; then\n #################\n # Install ninja #\n #################\n if [ \"$TRAVIS_OS_NAME\" = 'linux' ]; then\n # NNPACK needs a recent version\n if [ -e \"${BUILD_NINJA_DIR}/ninja\" ]; then\n echo \"Using cached ninja build at \\\"$BUILD_NINJA_DIR\\\" ...\"\n else\n git clone https://github.com/ninja-build/ninja.git -b release \"$BUILD_NINJA_DIR\"\n pushd \"$BUILD_NINJA_DIR\"\n python configure.py --bootstrap\n popd\n fi\n sudo install -m 755 \"${BUILD_NINJA_DIR}/ninja\" /usr/local/bin/ninja\n elif [ \"$TRAVIS_OS_NAME\" = 'osx' ]; then\n brew install ninja\n else\n echo \"OS \\\"$TRAVIS_OS_NAME\\\" is unknown\"\n exit 1\n fi\n sudo pip install git+https://github.com/Maratyszcza/PeachPy\n sudo pip install git+https://github.com/Maratyszcza/confu\nfi\n" }, { "path": ".travis/setup.sh", "content": "#!/bin/bash\n# This script should be sourced, not executed\nset -e\n\nexport BUILD_ANDROID=false\nexport BUILD_CUDA=false\nexport BUILD_GCC5=false\nexport BUILD_IOS=false\nexport BUILD_MKL=false\nexport BUILD_NNPACK=true\nexport BUILD_TESTS=true\n\nif [ \"$BUILD\" = 'linux' ]; then\n :\nelif [ \"$BUILD\" = 'linux-gcc5' ]; then\n export BUILD_GCC5=true\nelif [ \"$BUILD\" = 'linux-cuda' ]; then\n export BUILD_CUDA=true\n export BUILD_NNPACK=false\n export BUILD_TESTS=false\nelif [ \"$BUILD\" = 'linux-mkl' ]; then\n export BUILD_MKL=true\n export BUILD_TESTS=false\nelif [ \"$BUILD\" = 'linux-android' ]; then\n export BUILD_ANDROID=true\n export BUILD_TESTS=false\nelif [ \"$BUILD\" = 'osx' ]; then\n # TODO(lukeyeager): enable after caffe2/caffe2#785\n export BUILD_TESTS=false\n # Since Python 2.7.14, HomeBrew does not link python and pip in /usr/local/bin/,\n # but they are available in /usr/local/opt/python/libexec/bin/\n export PATH=\"/usr/local/opt/python/libexec/bin:${PATH}\"\nelif [ \"$BUILD\" = 'osx-ios' ]; then\n export BUILD_IOS=true\n export BUILD_TESTS=false\n # Since Python 2.7.14, HomeBrew does not link python and pip in /usr/local/bin/,\n # but they are available in /usr/local/opt/python/libexec/bin/\n export PATH=\"/usr/local/opt/python/libexec/bin:${PATH}\"\nelif [ \"$BUILD\" = 'osx-android' ]; then\n export BUILD_ANDROID=true\n export BUILD_TESTS=false\n # Since Python 2.7.14, HomeBrew does not link python and pip in /usr/local/bin/,\n # but they are available in /usr/local/opt/python/libexec/bin/\n export PATH=\"/usr/local/opt/python/libexec/bin:${PATH}\"\nelse\n echo \"BUILD \\\"$BUILD\\\" is unknown\"\n exit 1\nfi\n" }, { "path": ".travis/test.sh", "content": "#!/bin/bash\nset -e\nset -x\n\nLOCAL_DIR=$( cd \"$( dirname \"${BASH_SOURCE[0]}\" )\" && pwd )\nROOT_DIR=$(dirname \"$LOCAL_DIR\")\ncd \"$ROOT_DIR\"\n\nif [ \"$BUILD_TESTS\" = 'false' ]; then\n echo 'Skipping tests'\n exit 0\nfi\n\n# Ctests\npushd build\nCTEST_OUTPUT_ON_FAILURE=1 make test\npopd\n\n# Python tests\nexport PYTHONPATH=\"${PYTHONPATH}:${ROOT_DIR}/install\"\nexport LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:${ROOT_DIR}/install/lib\"\npython -m pytest -v install/caffe2/python\n" }, { "path": ".travis.yml", "content": "os: linux\ndist: trusty\nsudo: required\nlanguage: cpp\ncompiler: gcc\n\nenv:\n global:\n - BUILD_CCACHE_DIR=~/build/ccache\n - BUILD_NINJA_DIR=~/build/ninja\n matrix:\n - BUILD=linux\n - BUILD=linux-gcc5\n - BUILD=linux-cuda\n - BUILD=linux-mkl\n - BUILD=linux-android\n\nmatrix:\n include:\n - env: BUILD=osx\n os: osx\n osx_image: xcode8.3\n compiler: clang\n - env: BUILD=osx-ios\n os: osx\n osx_image: xcode8.3\n compiler: clang\n - env: BUILD=osx-android\n os: osx\n osx_image: xcode8.3\n compiler: clang\n\ncache:\n directories:\n - $BUILD_CCACHE_DIR\n - $BUILD_NINJA_DIR\n - $HOME/.ccache\n\nbefore_install:\n - source .travis/setup.sh\n\ninstall:\n - ./.travis/install.sh\n - ./.travis/build.sh\n\nscript:\n - ./.travis/test.sh\n" }, { "path": "CMakeLists.txt", "content": "cmake_minimum_required(VERSION 3.2 FATAL_ERROR)\n#cmake_policy(SET CMP0022 NEW)\n#cmake_policy(SET CMP0023 NEW)\n\n# ---[ Project and semantic versioning.\nproject(Caffe2 CXX C)\n\nset(CAFFE2_VERSION_MAJOR 0)\nset(CAFFE2_VERSION_MINOR 8)\nset(CAFFE2_VERSION_PATCH 2)\nset(CAFFE2_VERSION\n \"${CAFFE2_VERSION_MAJOR}.${CAFFE2_VERSION_MINOR}.${CAFFE2_VERSION_PATCH}\")\n\n# One variable that determines whether the current cmake process is being run\n# with the main Caffe2 library. This is useful for building modules - if\n# modules are built with the main Caffe2 library then one does not need to do\n# find caffe2 in the cmake script. One can usually guard it in some way like\n# if (NOT CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO)\n# find_package(Caffe2 REQUIRED)\n# endif()\nset(CAFFE2_CMAKE_BUILDING_WITH_MAIN_REPO ON)\n\n# ---[ Options.\n# Note to developers: if you add an option below, make sure you also add it to\n# cmake/Summary.cmake so that the summary prints out the option values.\ninclude(CMakeDependentOption)\noption(BUILD_BINARY \"Build C++ binaries\" ON)\noption(BUILD_DOCS \"Build documentation\" OFF)\noption(BUILD_CUSTOM_PROTOBUF \"If set, build Caffe2's own protobuf under third_party\" OFF)\noption(BUILD_PYTHON \"Build Python binaries\" ON)\noption(BUILD_SHARED_LIBS \"Build libcaffe2.so\" ON)\ncmake_dependent_option(\n CAFFE2_USE_MSVC_STATIC_RUNTIME \"Using MSVC static runtime libraries\" ON\n \"NOT BUILD_SHARED_LIBS\" OFF)\noption(BUILD_TEST \"Build C++ test binaries (need gtest and gbenchmark)\" ON)\noption(USE_ACL \"Use ARM Compute Library\" OFF)\noption(USE_ASAN \"Use Address Sanitizer\" OFF)\noption(USE_ATEN \"Use ATen\" OFF)\noption(USE_CUDA \"Use Cuda\" ON)\noption(USE_FFMPEG \"Use ffmpeg\" OFF)\noption(USE_GFLAGS \"Use GFLAGS\" ON)\noption(USE_GLOG \"Use GLOG\" ON)\noption(USE_GLOO \"Use Gloo\" ON)\noption(USE_LEVELDB \"Use LEVELDB\" ON)\noption(USE_LITE_PROTO \"Use lite protobuf instead of full.\" OFF)\noption(USE_LMDB \"Use LMDB\" ON)\noption(USE_METAL \"Use Metal for iOS build\" ON)\noption(USE_MOBILE_OPENGL \"Use OpenGL for mobile code\" ON)\noption(USE_MPI \"Use MPI\" ON)\noption(USE_NATIVE_ARCH \"Use -march=native\" OFF)\noption(USE_NCCL \"Use NCCL\" ON)\noption(USE_NERVANA_GPU \"Use Nervana GPU backend\" OFF)\noption(USE_NNAPI \"Use NNAPI\" OFF)\noption(USE_NNPACK \"Use NNPACK\" ON)\noption(USE_NUMA \"Use NUMA (only available on Linux)\" ON)\noption(USE_OBSERVERS \"Use observers module.\" OFF)\noption(USE_OPENCV \"Use openCV\" ON)\noption(USE_OPENMP \"Use OpenMP for parallel code\" OFF)\noption(USE_PROF \"Use profiling\" OFF)\noption(USE_REDIS \"Use Redis\" OFF)\noption(USE_ROCKSDB \"Use RocksDB\" OFF)\noption(USE_SNPE \"Use Qualcomm's SNPE library\" OFF)\noption(USE_THREADS \"Use Threads\" ON)\noption(USE_ZMQ \"Use ZMQ\" OFF)\noption(USE_ZSTD \"Use ZSTD\" OFF)\n\n# ---[ CMake scripts + modules\nlist(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/Modules)\n\nif (MSVC AND ${BUILD_SHARED_LIBS})\n set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)\nendif()\n\n# ---[ CMake build directories\nset(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)\nset(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)\nset(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)\n\nenable_testing()\n\n# ---[ Misc checks to cope with various compiler modes\ninclude(cmake/MiscCheck.cmake)\ninclude(cmake/BuildVariables.cmake)\n\n# External projects\ninclude(ExternalProject)\n\n# TODO: merge the following 3 files into cmake/public/utils.cmake.\ninclude(cmake/Utils.cmake)\ninclude(cmake/public/utils.cmake)\n\nset(CAFFE2_WHITELIST \"\" CACHE STRING \"A whitelist file of files that one should build.\")\n\n# Set default build type\nif(NOT CMAKE_BUILD_TYPE)\n message(STATUS \"Build type not set - defaulting to Release\")\n set(CMAKE_BUILD_TYPE \"Release\" CACHE STRING \"Choose the type of build from: Debug Release RelWithDebInfo MinSizeRel Coverage.\" FORCE)\nendif()\n\n# ---[ Dependencies\ninclude(cmake/Dependencies.cmake)\n\n# ---[ Whitelist file if whitelist is specified\ninclude(cmake/Whitelist.cmake)\n\n# ---[ Set link flag, handle additional deps for gcc 4.8 and above\nif(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.8.0 AND NOT ANDROID)\n message(STATUS \"GCC ${CMAKE_CXX_COMPILER_VERSION}: Adding gcc and gcc_s libs to link line\")\n list(APPEND Caffe2_DEPENDENCY_LIBS gcc_s gcc)\nendif()\n\n# ---[ Build flags\nset(CMAKE_C_STANDARD 99)\nset(CMAKE_CXX_STANDARD 11)\nif(NOT MSVC)\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -O2 -fPIC\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-narrowing\")\n # Eigen fails to build with some versions, so convert this to a warning\n # Details at http://eigen.tuxfamily.org/bz/show_bug.cgi?id=1459\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-invalid-partial-specialization\")\nelse()\n foreach(flag_var\n CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE\n CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)\n if (${CAFFE2_USE_MSVC_STATIC_RUNTIME})\n if(${flag_var} MATCHES \"/MD\")\n string(REGEX REPLACE \"/MD\" \"/MT\" ${flag_var} \"${${flag_var}}\")\n endif(${flag_var} MATCHES \"/MD\")\n else()\n if(${flag_var} MATCHES \"/MT\")\n string(REGEX REPLACE \"/MT\" \"/MD\" ${flag_var} \"${${flag_var}}\")\n endif()\n endif()\n set(${flag_var} \"${${flag_var}} /MP /bigobj\")\n endforeach(flag_var)\nendif()\n\nif(ANDROID)\n if(CMAKE_COMPILER_IS_GNUCXX)\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -s\")\n else()\n set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS} -s\")\n endif()\nendif()\n\nif(NOT APPLE AND UNIX)\n list(APPEND Caffe2_DEPENDENCY_LIBS dl)\nendif()\n\n# Prefix path to Caffe2 headers.\n# If a directory containing installed Caffe2 headers was inadvertently\n# added to the list of include directories, prefixing\n# PROJECT_SOURCE_DIR means this source tree always takes precedence.\ninclude_directories(BEFORE ${PROJECT_SOURCE_DIR})\n\n# Prefix path to generated Caffe2 headers.\n# These need to take precedence over their empty counterparts located\n# in PROJECT_SOURCE_DIR.\ninclude_directories(BEFORE ${PROJECT_BINARY_DIR})\n\n# ---[ Old caffe protobuf.\nadd_subdirectory(caffe/proto)\n\n# ---[ Main build\nadd_subdirectory(caffe2)\n\n# Documentation Option\nif(BUILD_DOCS)\n # check if Doxygen is installed\n find_package(Doxygen)\n if (DOXYGEN_FOUND)\n message(\"Generating documentation\")\n\n set(DOXYGEN_C_IN ${CMAKE_CURRENT_SOURCE_DIR}/docs/.Doxyfile-c)\n set(DOXYGEN_C_OUT ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile-c)\n set(DOXYGEN_P_IN ${CMAKE_CURRENT_SOURCE_DIR}/docs/.Doxyfile-python)\n set(DOXYGEN_P_OUT ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile-python)\n\n if(EXISTS ${CMAKE_CURRENT_BINARY_DIR}/docs)\n file(REMOVE_RECURSE ${CMAKE_CURRENT_BINARY_DIR}/docs)\n endif (EXISTS ${CMAKE_CURRENT_BINARY_DIR}/docs)\n\n file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/docs)\n configure_file(${DOXYGEN_C_IN} ${DOXYGEN_C_OUT} @ONLY)\n configure_file(${DOXYGEN_P_IN} ${DOXYGEN_P_OUT} @ONLY)\n\n add_custom_target(doc_doxygen_c ALL\n COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_C_OUT}\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}\n COMMENT \"Generating C++ API documentation with Doxygen\"\n VERBATIM)\n\n add_custom_target(doc_doxygen_python ALL\n COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_P_OUT}\n WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}\n COMMENT \"Generating Python API documentation with Doxygen\"\n VERBATIM)\n else (DOXYGEN_FOUND)\n message(FATAL_ERROR \"Doxygen needs to be installed to generate the documentation\")\n endif (DOXYGEN_FOUND)\nendif (BUILD_DOCS)\n\n# ---[ CMake related files\n# Uninistall option.\nif(NOT TARGET caffe2_uninstall)\n configure_file(\n ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in\n ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake\n IMMEDIATE @ONLY)\n\n add_custom_target(caffe2_uninstall\n COMMAND ${CMAKE_COMMAND} -P\n ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)\nendif()\n\n# ---[ Make configuration files for cmake to allow dependent libraries\n# easier access to Caffe2.\n\nif ((NOT USE_GLOG) OR (NOT USE_GFLAGS) OR BUILD_CUSTOM_PROTOBUF)\n message(WARNING\n \"Generated cmake files are only fully tested if one builds \"\n \"with system glog, gflags, and protobuf. Other settings may \"\n \"generate files that are not well tested.\")\nendif()\n\nif (USE_CUDA)\n # TODO: check if we should include other cuda dependency libraries\n # to the interface as well.\n\nendif()\n\n# Note(jiayq): when building static libraries, all PRIVATE dependencies\n# will also become interface libraries, and as a result if there are any\n# dependency libraries that are not exported, the following install export\n# script will fail. As a result, we will only provide the targets cmake\n# files for shared lib installation. For more info, read:\n# https://cmake.org/pipermail/cmake/2016-May/063400.html\nif (BUILD_SHARED_LIBS)\n configure_file(\n ${PROJECT_SOURCE_DIR}/cmake/Caffe2ConfigVersion.cmake.in\n ${PROJECT_BINARY_DIR}/Caffe2ConfigVersion.cmake\n @ONLY)\n configure_file(\n ${PROJECT_SOURCE_DIR}/cmake/Caffe2Config.cmake.in\n ${PROJECT_BINARY_DIR}/Caffe2Config.cmake\n @ONLY)\n install(FILES\n ${PROJECT_BINARY_DIR}/Caffe2ConfigVersion.cmake\n ${PROJECT_BINARY_DIR}/Caffe2Config.cmake\n DESTINATION share/cmake/Caffe2\n COMPONENT dev)\n install(FILES\n ${PROJECT_SOURCE_DIR}/cmake/public/cuda.cmake\n ${PROJECT_SOURCE_DIR}/cmake/public/glog.cmake\n ${PROJECT_SOURCE_DIR}/cmake/public/gflags.cmake\n ${PROJECT_SOURCE_DIR}/cmake/public/protobuf.cmake\n ${PROJECT_SOURCE_DIR}/cmake/public/threads.cmake\n ${PROJECT_SOURCE_DIR}/cmake/public/utils.cmake\n DESTINATION share/cmake/Caffe2/public\n COMPONENT dev)\n install(EXPORT Caffe2Targets DESTINATION share/cmake/Caffe2\n FILE Caffe2Targets.cmake\n COMPONENT dev)\nelse()\n message(WARNING\n \"Generated cmake files are only available when building \"\n \"shared libs.\")\nendif()\n\n# ---[ Modules\nadd_subdirectory(modules)\n\n# ---[ Binaries\n# Binaries will be built after the Caffe2 main libraries and the modules\n# are built. For the binaries, they will be linked to the Caffe2 main\n# libraries, as well as all the modules that are built with Caffe2 (the ones\n# built in the previous Modules section above).\n\nif (BUILD_BINARY)\n add_subdirectory(binaries)\nendif()\n\ninclude(cmake/Summary.cmake)\ncaffe2_print_configuration_summary()\n" }, { "path": "LICENSE", "content": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n" }, { "path": "Makefile", "content": "# This makefile does nothing but delegating the actual building to cmake.\n\nall:\n\t@mkdir -p build && cd build && cmake .. $(shell python ./scripts/get_python_cmake_flags.py) && $(MAKE)\n\nlocal:\n\t@./scripts/build_local.sh\n\nandroid:\n\t@./scripts/build_android.sh\n\nios:\n\t@./scripts/build_ios.sh\n\nclean: # This will remove ALL build folders.\n\t@rm -r build*/\n\nlinecount:\n\t@cloc --read-lang-def=caffe.cloc caffe2 || \\\n\t\techo \"Cloc is not available on the machine. You can install cloc with \" && \\\n\t\techo \" sudo apt-get install cloc\"\n" }, { "path": "NOTICE", "content": "Copyright (c) 2016-present, Facebook Inc. All rights reserved.\n\nAll contributions by Facebook:\nCopyright (c) 2016 Facebook Inc.\n \nAll contributions by Google:\nCopyright (c) 2015 Google Inc.\nAll rights reserved.\n \nAll contributions by Yangqing Jia:\nCopyright (c) 2015 Yangqing Jia\nAll rights reserved.\n \nAll contributions from Caffe:\nCopyright(c) 2013, 2014, 2015, the respective contributors\nAll rights reserved.\n \nAll other contributions:\nCopyright(c) 2015, 2016 the respective contributors\nAll rights reserved.\n \nCaffe2 uses a copyright model similar to Caffe: each contributor holds\ncopyright over their contributions to Caffe2. The project versioning records\nall such contribution and copyright details. If a contributor wants to further\nmark their specific copyright on a particular contribution, they should\nindicate their copyright solely in the commit message of the change when it is\ncommitted.\n\n=======================================================================\nSoftware under third_party\n=======================================================================\nSoftware libraries under third_party are provided as github submodule\nlinks, and their content is not part of the Caffe2 codebase. Their\nlicences can be found under the respective software repositories.\n\n=======================================================================\nEarlier BSD License\n=======================================================================\nEarly development of Caffe2 in 2015 and early 2016 is licensed under the\nBSD license. The license is attached below:\n\nAll contributions by Facebook:\nCopyright (c) 2016 Facebook Inc.\n\nAll contributions by Google:\nCopyright (c) 2015 Google Inc.\nAll rights reserved.\n\nAll contributions by Yangqing Jia:\nCopyright (c) 2015 Yangqing Jia\nAll rights reserved.\n\nAll other contributions:\nCopyright(c) 2015, 2016 the respective contributors\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\n=======================================================================\nCaffe's BSD License\n=======================================================================\nSome parts of the caffe2 code is derived from the original Caffe code, which is\ncreated by Yangqing Jia and is now a BSD-licensed open-source project. The Caffe\nlicense is as follows:\n\nCOPYRIGHT\n\nAll contributions by the University of California:\nCopyright (c) 2014, The Regents of the University of California (Regents)\nAll rights reserved.\n\nAll other contributions:\nCopyright (c) 2014, the respective contributors\nAll rights reserved.\n\nCaffe uses a shared copyright model: each contributor holds copyright over\ntheir contributions to Caffe. The project versioning records all such\ncontribution and copyright details. If a contributor wants to further mark\ntheir specific copyright on a particular contribution, they should indicate\ntheir copyright solely in the commit message of the change when it is\ncommitted.\n\nLICENSE\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nCONTRIBUTION AGREEMENT\n\nBy contributing to the BVLC/caffe repository through pull-request, comment,\nor otherwise, the contributor releases their content to the\nlicense and copyright terms herein.\n\n" }, { "path": "README.md", "content": "# Caffe2\n\n[![License](https://img.shields.io/badge/License-Apache%202.0-brightgreen.svg)](https://opensource.org/licenses/Apache-2.0)\n[![Jenkins Build Status](https://ci.pytorch.org/jenkins/job/caffe2-master/badge/icon)](https://ci.pytorch.org/jenkins/job/caffe2-master)\n[![Appveyor Build Status](https://img.shields.io/appveyor/ci/Yangqing/caffe2.svg)](https://ci.appveyor.com/project/Yangqing/caffe2)\n\nCaffe2 is a lightweight, modular, and scalable deep learning framework. Building on the original [Caffe](http://caffe.berkeleyvision.org), Caffe2 is designed with expression, speed, and modularity in mind.\n\n## Questions and Feedback\n\nPlease use Github issues (https://github.com/caffe2/caffe2/issues) to ask questions, report bugs, and request new features.\n\nPlease participate in our survey (https://www.surveymonkey.com/r/caffe2). We will send you information about new releases and special developer events/webinars.\n\n\n## License\n\nCaffe2 is released under the [Apache 2.0 license](https://github.com/caffe2/caffe2/blob/master/LICENSE). See the [NOTICE](https://github.com/caffe2/caffe2/blob/master/NOTICE) file for details.\n\n### Further Resources on [Caffe2.ai](http://caffe2.ai)\n\n* [Installation](http://caffe2.ai/docs/getting-started.html)\n* [Learn More](http://caffe2.ai/docs/learn-more.html)\n* [Upgrading to Caffe2](http://caffe2.ai/docs/caffe-migration.html)\n* [Datasets](http://caffe2.ai/docs/datasets.html)\n* [Model Zoo](http://caffe2.ai/docs/zoo.html)\n* [Tutorials](http://caffe2.ai/docs/tutorials.html)\n* [Operators Catalogue](http://caffe2.ai/docs/operators-catalogue.html)\n* [C++ API](http://caffe2.ai/doxygen-c/html/classes.html)\n* [Python API](http://caffe2.ai/doxygen-python/html/namespaces.html)\n" }, { "path": "VERSION_NUMBER", "content": "0.8.1" }, { "path": "appveyor.yml", "content": "version: '{build}'\nclone_folder: c:\\projects\\caffe2\nenvironment:\n matrix:\n - USE_CUDA: OFF\n CMAKE_BUILD_TYPE: Release\n APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017\n\n # Building CUDA with Visual Studio 2017 is yet to be supported by\n # NVidia, so we canot enable it right now.\n #- USE_CUDA: ON\n # CMAKE_BUILD_TYPE: Release\n # APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017\n \n # Building CUDA currently causes a timeout in appveyor. In the interest\n # of properly monitoring the rest, we will disable cuda contbuild for now.\n #- USE_CUDA: ON\n # CMAKE_BUILD_TYPE: Release\n # APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015\n\n - USE_CUDA: OFF\n CMAKE_BUILD_TYPE: Release\n APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015\n\n # Debug build is not a top priority for us right now, so in the\n # interest of contbuild time, we disable it.\n #- USE_CUDA: OFF\n # CMAKE_BUILD_TYPE: Debug\n # APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017\n\n # Currently, CUDA + Debug does not work due to an error of using\n # std::_Debug_lt in device code. Not sure where this comes from yet,\n # but it is probably safe to assume that very few are going to build\n # debug mode with CUDA and Windows.\n #- USE_CUDA: ON\n # CMAKE_BUILD_TYPE: Debug\n\ninstall:\n- cmd: c:\\projects\\caffe2\\scripts\\appveyor\\install.bat\n\nbuild_script:\n- cmd: >-\n cd c:\\projects\\caffe2\n\n git submodule update --init\n\n call scripts\\build_windows.bat\n" }, { "path": "binaries/CMakeLists.txt", "content": "caffe2_binary_target(\"convert_caffe_image_db.cc\")\ncaffe2_binary_target(\"convert_db.cc\")\ncaffe2_binary_target(\"make_cifar_db.cc\")\ncaffe2_binary_target(\"make_mnist_db.cc\")\ncaffe2_binary_target(\"predictor_verifier.cc\")\ncaffe2_binary_target(\"print_registered_core_operators.cc\")\ncaffe2_binary_target(\"run_plan.cc\")\ncaffe2_binary_target(\"speed_benchmark.cc\")\ncaffe2_binary_target(\"split_db.cc\")\n\ncaffe2_binary_target(\"db_throughput.cc\")\n\nif (USE_CUDA)\n caffe2_binary_target(\"inspect_gpus.cc\")\n target_link_libraries(inspect_gpus ${CUDA_LIBRARIES})\n caffe2_binary_target(\"print_core_object_sizes.cc\")\n\n if (BUILD_TEST)\n # Core overhead benchmark\n caffe2_binary_target(\"core_overhead_benchmark.cc\")\n target_link_libraries(core_overhead_benchmark benchmark ${CUDA_curand_LIBRARY})\n endif()\nendif()\n\nif (USE_ZMQ)\n caffe2_binary_target(\"zmq_feeder.cc\")\n target_link_libraries(zmq_feeder ${ZMQ_LIBRARIES})\nendif()\n\nif(USE_MPI)\n caffe2_binary_target(\"run_plan_mpi.cc\")\n target_link_libraries(run_plan_mpi ${MPI_CXX_LIBRARIES})\nendif()\n\nif (USE_OPENCV AND USE_LEVELDB)\n caffe2_binary_target(\"convert_encoded_to_raw_leveldb.cc\")\n target_link_libraries(\n convert_encoded_to_raw_leveldb\n ${OpenCV_LIBS} ${LevelDB_LIBRARIES} ${Snappy_LIBRARIES})\nendif()\n\nif (USE_OPENCV)\n caffe2_binary_target(\"make_image_db.cc\")\n target_link_libraries(make_image_db ${OpenCV_LIBS})\nendif()\n\nif (USE_OBSERVERS)\n caffe2_binary_target(\"caffe2_benchmark.cc\")\nendif()\n\n# ---[ tutorials\ncaffe2_binary_target(\"tutorial_blob.cc\")\n" }, { "path": "binaries/caffe2_benchmark.cc", "content": "#include \n#include \n#include \n\n#include \"caffe2/core/blob_serialization.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/logging.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/utils/proto_utils.h\"\n#include \"caffe2/utils/string_utils.h\"\n\n#include \"observers/observer_config.h\"\n\nCAFFE2_DEFINE_string(\n backend,\n \"builtin\",\n \"The backend to use when running the model. The allowed \"\n \"backend choices are: builtin, default, nnpack, eigen, mkl\");\nCAFFE2_DEFINE_string(\n init_net,\n \"\",\n \"The given net to initialize any parameters.\");\nCAFFE2_DEFINE_string(\n input,\n \"\",\n \"Input that is needed for running the network. If \"\n \"multiple input needed, use comma separated string.\");\nCAFFE2_DEFINE_string(\n input_dims,\n \"\",\n \"Alternate to input_files, if all inputs are simple \"\n \"float TensorCPUs, specify the dimension using comma \"\n \"separated numbers. If multiple input needed, use \"\n \"semicolon to separate the dimension of different \"\n \"tensors.\");\nCAFFE2_DEFINE_string(\n input_file,\n \"\",\n \"Input file that contain the serialized protobuf for \"\n \"the input blobs. If multiple input needed, use comma \"\n \"separated string. Must have the same number of items \"\n \"as input does.\");\nCAFFE2_DEFINE_string(\n input_type,\n \"float\",\n \"Input type when specifying the input dimension.\"\n \"The supported types are float, uint8_t.\");\nCAFFE2_DEFINE_int(iter, 10, \"The number of iterations to run.\");\nCAFFE2_DEFINE_string(net, \"\", \"The given net to benchmark.\");\nCAFFE2_DEFINE_string(\n output,\n \"\",\n \"Output that should be dumped after the execution \"\n \"finishes. If multiple outputs are needed, use comma \"\n \"separated string. If you want to dump everything, pass \"\n \"'*' as the output value.\");\nCAFFE2_DEFINE_string(\n output_folder,\n \"\",\n \"The folder that the output should be written to. This \"\n \"folder must already exist in the file system.\");\nCAFFE2_DEFINE_bool(\n run_individual,\n false,\n \"Whether to benchmark individual operators.\");\nCAFFE2_DEFINE_bool(\n text_output,\n false,\n \"Whether to write out output in text format for regression purpose.\");\nCAFFE2_DEFINE_int(warmup, 0, \"The number of iterations to warm up.\");\n\nusing std::string;\nusing std::unique_ptr;\nusing std::vector;\n\nstatic void writeTextOutput(\n caffe2::TensorCPU* tensor,\n const string& output_prefix,\n const string& name) {\n string output_name = output_prefix + \"/\" + name + \".txt\";\n caffe2::TensorSerializer ser;\n caffe2::BlobProto blob_proto;\n ser.Serialize(\n *tensor, output_name, blob_proto.mutable_tensor(), 0, tensor->size());\n blob_proto.set_name(output_name);\n blob_proto.set_type(\"Tensor\");\n CAFFE_ENFORCE(blob_proto.has_tensor());\n caffe2::TensorProto tensor_proto = blob_proto.tensor();\n vector data;\n switch (tensor_proto.data_type()) {\n case caffe2::TensorProto::FLOAT: {\n std::copy(\n tensor_proto.float_data().begin(),\n tensor_proto.float_data().end(),\n std::back_inserter(data));\n break;\n }\n case caffe2::TensorProto::INT32: {\n std::copy(\n tensor_proto.int32_data().begin(),\n tensor_proto.int32_data().end(),\n std::back_inserter(data));\n break;\n }\n default:\n CAFFE_THROW(\"Unimplemented Blob type.\");\n }\n std::ofstream output_file(output_name);\n std::ostream_iterator output_iterator(output_file, \"\\n\");\n std::copy(data.begin(), data.end(), output_iterator);\n}\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::ShowLogInfoToStderr();\n unique_ptr workspace(new caffe2::Workspace());\n\n // Run initialization network.\n caffe2::NetDef init_net_def;\n CAFFE_ENFORCE(ReadProtoFromFile(caffe2::FLAGS_init_net, &init_net_def));\n CAFFE_ENFORCE(workspace->RunNetOnce(init_net_def));\n\n // Load input.\n if (caffe2::FLAGS_input.size()) {\n vector input_names = caffe2::split(',', caffe2::FLAGS_input);\n if (caffe2::FLAGS_input_file.size()) {\n vector input_files = caffe2::split(',', caffe2::FLAGS_input_file);\n CAFFE_ENFORCE_EQ(\n input_names.size(),\n input_files.size(),\n \"Input name and file should have the same number.\");\n for (int i = 0; i < input_names.size(); ++i) {\n caffe2::BlobProto blob_proto;\n CAFFE_ENFORCE(caffe2::ReadProtoFromFile(input_files[i], &blob_proto));\n workspace->CreateBlob(input_names[i])->Deserialize(blob_proto);\n }\n } else if (caffe2::FLAGS_input_dims.size()) {\n vector input_dims_list =\n caffe2::split(';', caffe2::FLAGS_input_dims);\n CAFFE_ENFORCE_EQ(\n input_names.size(),\n input_dims_list.size(),\n \"Input name and dims should have the same number of items.\");\n for (int i = 0; i < input_names.size(); ++i) {\n vector input_dims_str = caffe2::split(',', input_dims_list[i]);\n vector input_dims;\n for (const string& s : input_dims_str) {\n input_dims.push_back(caffe2::stoi(s));\n }\n if (!workspace->HasBlob(input_names[i])) {\n workspace->CreateBlob(input_names[i]);\n }\n caffe2::TensorCPU* tensor =\n workspace->GetBlob(input_names[i])->GetMutable();\n tensor->Resize(input_dims);\n if (caffe2::FLAGS_input_type == \"float\") {\n tensor->mutable_data();\n } else {\n CAFFE_ENFORCE(\n caffe2::FLAGS_input_type == \"uint8_t\",\n \"Only supported input types are: float, uint8_t\");\n tensor->mutable_data();\n }\n }\n } else {\n CAFFE_THROW(\n \"You requested input tensors, but neither input_file nor \"\n \"input_dims is set.\");\n }\n }\n\n // Run main network.\n caffe2::NetDef net_def;\n CAFFE_ENFORCE(ReadProtoFromFile(caffe2::FLAGS_net, &net_def));\n if (caffe2::FLAGS_backend != \"builtin\") {\n std::string engine = caffe2::FLAGS_backend == \"nnpack\" ? \"NNPACK\" :\n caffe2::FLAGS_backend == \"eigen\" ? \"EIGEN\" :\n caffe2::FLAGS_backend == \"mkl\" ? \"MKLDNN\" :\n caffe2::FLAGS_backend == \"default\" ? \"\" : \"NONE\";\n CAFFE_ENFORCE(engine != \"NONE\", \"Backend is not supported\");\n for (int i = 0; i < net_def.op_size(); i++) {\n caffe2::OperatorDef* op_def = net_def.mutable_op(i);\n op_def->set_engine(engine);\n }\n }\n\n caffe2::NetBase* net = workspace->CreateNet(net_def);\n CHECK_NOTNULL(net);\n\n LOG(INFO) << \"Starting benchmark.\";\n caffe2::ObserverConfig::initSampleRate(\n 1, 1, 1, caffe2::FLAGS_run_individual, caffe2::FLAGS_warmup);\n LOG(INFO) << \"Running warmup runs.\";\n for (int i = 0; i < caffe2::FLAGS_warmup; ++i) {\n CAFFE_ENFORCE(net->Run(), \"Warmup run \", i, \" has failed.\");\n }\n\n LOG(INFO) << \"Main runs.\";\n CAFFE_ENFORCE(\n caffe2::FLAGS_iter >= 0,\n \"Number of main runs should be non negative, provided \",\n caffe2::FLAGS_iter,\n \".\");\n for (int i = 0; i < caffe2::FLAGS_iter; ++i) {\n caffe2::ObserverConfig::initSampleRate(1, 1, 1, 0, caffe2::FLAGS_warmup);\n CAFFE_ENFORCE(net->Run(), \"Main run \", i, \" has failed.\");\n if (caffe2::FLAGS_run_individual) {\n caffe2::ObserverConfig::initSampleRate(1, 1, 1, 1, caffe2::FLAGS_warmup);\n CAFFE_ENFORCE(net->Run(), \"Main run \", i, \" with operator has failed.\");\n }\n }\n\n string output_prefix = caffe2::FLAGS_output_folder.size()\n ? caffe2::FLAGS_output_folder + \"/\"\n : \"\";\n if (caffe2::FLAGS_output.size()) {\n vector output_names = caffe2::split(',', caffe2::FLAGS_output);\n if (caffe2::FLAGS_output == \"*\") {\n output_names = workspace->Blobs();\n }\n for (const string& name : output_names) {\n CAFFE_ENFORCE(\n workspace->HasBlob(name),\n \"You requested a non-existing blob: \",\n name);\n if (caffe2::FLAGS_text_output) {\n auto blob = workspace->GetBlob(name)->GetMutable();\n writeTextOutput(blob, output_prefix, name);\n } else {\n string serialized = workspace->GetBlob(name)->Serialize(name);\n string output_filename = output_prefix + name;\n caffe2::WriteStringToFile(serialized, output_filename.c_str());\n }\n }\n }\n\n return 0;\n}\n" }, { "path": "binaries/convert_caffe_image_db.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe/proto/caffe.pb.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(input_db, \"\", \"The input db.\");\nCAFFE2_DEFINE_string(input_db_type, \"\", \"The input db type.\");\nCAFFE2_DEFINE_string(output_db, \"\", \"The output db.\");\nCAFFE2_DEFINE_string(output_db_type, \"\", \"The output db type.\");\nCAFFE2_DEFINE_int(batch_size, 1000, \"The write batch size.\");\n\nusing caffe2::db::Cursor;\nusing caffe2::db::DB;\nusing caffe2::db::Transaction;\nusing caffe2::TensorProto;\nusing caffe2::TensorProtos;\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n\n std::unique_ptr in_db(caffe2::db::CreateDB(\n caffe2::FLAGS_input_db_type, caffe2::FLAGS_input_db, caffe2::db::READ));\n std::unique_ptr out_db(caffe2::db::CreateDB(\n caffe2::FLAGS_output_db_type, caffe2::FLAGS_output_db, caffe2::db::NEW));\n std::unique_ptr cursor(in_db->NewCursor());\n std::unique_ptr transaction(out_db->NewTransaction());\n int count = 0;\n for (; cursor->Valid(); cursor->Next()) {\n caffe::Datum datum;\n CAFFE_ENFORCE(datum.ParseFromString(cursor->value()));\n TensorProtos protos;\n TensorProto* data = protos.add_protos();\n TensorProto* label = protos.add_protos();\n label->set_data_type(TensorProto::INT32);\n label->add_dims(1);\n label->add_int32_data(datum.label());\n if (datum.encoded()) {\n // This is an encoded image. we will copy over the data directly.\n data->set_data_type(TensorProto::STRING);\n data->add_dims(1);\n data->add_string_data(datum.data());\n } else {\n // float data not supported right now.\n CAFFE_ENFORCE_EQ(datum.float_data_size(), 0);\n std::vector buffer_vec(datum.data().size());\n char* buffer = buffer_vec.data();\n // swap order from CHW to HWC\n int channels = datum.channels();\n int size = datum.height() * datum.width();\n CAFFE_ENFORCE_EQ(datum.data().size(), channels * size);\n for (int c = 0; c < channels; ++c) {\n char* dst = buffer + c;\n const char* src = datum.data().c_str() + c * size;\n for (int n = 0; n < size; ++n) {\n dst[n*channels] = src[n];\n }\n }\n data->set_data_type(TensorProto::BYTE);\n data->add_dims(datum.height());\n data->add_dims(datum.width());\n data->add_dims(datum.channels());\n data->set_byte_data(buffer, datum.data().size());\n }\n transaction->Put(cursor->key(), protos.SerializeAsString());\n if (++count % caffe2::FLAGS_batch_size == 0) {\n transaction->Commit();\n LOG(INFO) << \"Converted \" << count << \" items so far.\";\n }\n }\n LOG(INFO) << \"A total of \" << count << \" items processed.\";\n return 0;\n}\n\n" }, { "path": "binaries/convert_db.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(input_db, \"\", \"The input db.\");\nCAFFE2_DEFINE_string(input_db_type, \"\", \"The input db type.\");\nCAFFE2_DEFINE_string(output_db, \"\", \"The output db.\");\nCAFFE2_DEFINE_string(output_db_type, \"\", \"The output db type.\");\nCAFFE2_DEFINE_int(batch_size, 1000, \"The write batch size.\");\n\nusing caffe2::db::Cursor;\nusing caffe2::db::DB;\nusing caffe2::db::Transaction;\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n\n std::unique_ptr in_db(caffe2::db::CreateDB(\n caffe2::FLAGS_input_db_type, caffe2::FLAGS_input_db, caffe2::db::READ));\n std::unique_ptr out_db(caffe2::db::CreateDB(\n caffe2::FLAGS_output_db_type, caffe2::FLAGS_output_db, caffe2::db::NEW));\n std::unique_ptr cursor(in_db->NewCursor());\n std::unique_ptr transaction(out_db->NewTransaction());\n int count = 0;\n for (; cursor->Valid(); cursor->Next()) {\n transaction->Put(cursor->key(), cursor->value());\n if (++count % caffe2::FLAGS_batch_size == 0) {\n transaction->Commit();\n LOG(INFO) << \"Converted \" << count << \" items so far.\";\n }\n }\n LOG(INFO) << \"A total of \" << count << \" items processed.\";\n return 0;\n}\n" }, { "path": "binaries/convert_encoded_to_raw_leveldb.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// This script converts an image dataset to leveldb.\n//\n// caffe2::FLAGS_input_folder is the root folder that holds all the images, and\n// caffe2::FLAGS_list_file should be a list of files as well as their labels, in the\n// format as\n// subfolder1/file1.JPEG 7\n// ....\n\n#include \n\n#include // NOLINT(readability/streams)\n#include \n#include \n#include \n\n#include \"caffe2/core/init.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/core/logging.h\"\n#include \"leveldb/db.h\"\n#include \"leveldb/write_batch.h\"\n\nCAFFE2_DEFINE_string(input_db_name, \"\", \"The input image file name.\");\nCAFFE2_DEFINE_string(output_db_name, \"\", \"The output training leveldb name.\");\nCAFFE2_DEFINE_bool(color, true, \"If set, load images in color.\");\nCAFFE2_DEFINE_int(scale, 256,\n \"If caffe2::FLAGS_raw is set, scale all the images' shorter edge to the given \"\n \"value.\");\nCAFFE2_DEFINE_bool(warp, false, \"If warp is set, warp the images to square.\");\n\n\nnamespace caffe2 {\n\nusing std::string;\nusing std::unique_ptr;\n\nvoid ConvertToRawDataset(\n const string& input_db_name, const string& output_db_name) {\n // input leveldb\n std::unique_ptr input_db;\n LOG(INFO) << \"Opening input leveldb \" << input_db_name;\n {\n leveldb::Options options;\n options.create_if_missing = false;\n leveldb::DB* db_temp;\n leveldb::Status status = leveldb::DB::Open(\n options, input_db_name, &db_temp);\n CAFFE_ENFORCE(status.ok(), \"Failed to open leveldb \", input_db_name, \".\");\n input_db.reset(db_temp);\n }\n\n // output leveldb\n std::unique_ptr output_db;\n std::unique_ptr batch;\n LOG(INFO) << \"Opening leveldb \" << output_db_name;\n {\n leveldb::Options options;\n options.error_if_exists = true;\n options.create_if_missing = true;\n options.write_buffer_size = 268435456;\n leveldb::DB* db_temp;\n leveldb::Status status = leveldb::DB::Open(\n options, output_db_name, &db_temp);\n CAFFE_ENFORCE(\n status.ok(),\n \"Failed to open leveldb \",\n output_db_name,\n \". Is it already existing?\");\n output_db.reset(db_temp);\n }\n batch.reset(new leveldb::WriteBatch());\n\n TensorProtos input_protos;\n TensorProtos output_protos;\n TensorProto* data = output_protos.add_protos();\n TensorProto* label = output_protos.add_protos();\n data->set_data_type(TensorProto::BYTE);\n data->add_dims(0);\n data->add_dims(0);\n if (caffe2::FLAGS_color) {\n data->add_dims(3);\n }\n string value;\n\n unique_ptr iter;\n iter.reset(input_db->NewIterator(leveldb::ReadOptions()));\n iter->SeekToFirst();\n int count = 0;\n for (; iter->Valid(); iter->Next()) {\n CAFFE_ENFORCE(input_protos.ParseFromString(iter->value().ToString()));\n label->CopyFrom(input_protos.protos(1));\n const string& encoded_image = input_protos.protos(0).string_data(0);\n int encoded_size = encoded_image.size();\n cv::Mat img = cv::imdecode(\n cv::Mat(1, &encoded_size, CV_8UC1,\n const_cast(encoded_image.data())),\n caffe2::FLAGS_color ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);\n cv::Mat resized_img;\n int scaled_width, scaled_height;\n if (caffe2::FLAGS_warp) {\n scaled_width = caffe2::FLAGS_scale;\n scaled_height = caffe2::FLAGS_scale;\n } else if (img.rows > img.cols) {\n scaled_width = caffe2::FLAGS_scale;\n scaled_height = static_cast(img.rows) * caffe2::FLAGS_scale / img.cols;\n } else {\n scaled_height = caffe2::FLAGS_scale;\n scaled_width = static_cast(img.cols) * caffe2::FLAGS_scale / img.rows;\n }\n cv::resize(img, resized_img, cv::Size(scaled_width, scaled_height), 0, 0,\n cv::INTER_LINEAR);\n data->set_dims(0, scaled_height);\n data->set_dims(1, scaled_width);\n DCHECK(resized_img.isContinuous());\n data->set_byte_data(resized_img.ptr(),\n scaled_height * scaled_width * (caffe2::FLAGS_color ? 3 : 1));\n output_protos.SerializeToString(&value);\n // Put in db\n batch->Put(iter->key(), value);\n if (++count % 1000 == 0) {\n output_db->Write(leveldb::WriteOptions(), batch.get());\n batch.reset(new leveldb::WriteBatch());\n LOG(INFO) << \"Processed \" << count << \" files.\";\n }\n }\n // write the last batch\n if (count % 1000 != 0) {\n output_db->Write(leveldb::WriteOptions(), batch.get());\n }\n LOG(INFO) << \"Processed a total of \" << count << \" files.\";\n}\n\n} // namespace caffe2\n\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::ConvertToRawDataset(\n caffe2::FLAGS_input_db_name, caffe2::FLAGS_output_db_name);\n return 0;\n}\n" }, { "path": "binaries/core_overhead_benchmark.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"benchmark/benchmark.h\"\n\n#include \"caffe2/core/context.h\"\n#include \"caffe2/core/context_gpu.h\"\n#include \"caffe2/core/operator.h\"\n\n#define CAFFE2_SKIP_IF_NO_GPU \\\n if (!caffe2::NumCudaDevices()) { \\\n state.SkipWithError(\"No CUDA available, skipping benchmark.\"); \\\n return; \\\n }\n\nusing namespace caffe2;\n\nstatic void BM_CUDAContextCreation(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n volatile CUDAContext context_so_we_do_initialization_work;\n while (state.KeepRunning()) {\n volatile CUDAContext context;\n }\n}\nBENCHMARK(BM_CUDAContextCreation);\n\nstatic void BM_CUDAContextStreamAccess(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n CUDAContext context;\n while (state.KeepRunning()) {\n volatile cudaStream_t stream = context.cuda_stream();\n }\n}\nBENCHMARK(BM_CUDAContextStreamAccess);\n\nstatic void BM_cudaGetDevice(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n int id;\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaGetDevice(&id));\n }\n}\nBENCHMARK(BM_cudaGetDevice);\n\nstatic void BM_cudaSetDevice(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n int total = NumCudaDevices();\n int i = 0;\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaSetDevice((i++) % total));\n }\n}\nBENCHMARK(BM_cudaSetDevice);\n\nstatic void BM_cudaSetAndGetDevice(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n int total = NumCudaDevices();\n int i = 0;\n int id;\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaSetDevice((i++) % total));\n CUDA_ENFORCE(cudaGetDevice(&id));\n }\n}\nBENCHMARK(BM_cudaSetAndGetDevice);\n\nstatic void BM_cudaSetSameDevice(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaSetDevice(0));\n }\n}\nBENCHMARK(BM_cudaSetSameDevice);\n\nstatic void BM_cudaStreamCreateSyncDelete(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n cudaStream_t stream;\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaStreamCreate(&stream));\n CUDA_ENFORCE(cudaStreamSynchronize(stream));\n CUDA_ENFORCE(cudaStreamDestroy(stream));\n }\n}\nBENCHMARK(BM_cudaStreamCreateSyncDelete);\n\nstatic void BM_cudaStreamSynchronize(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n cudaStream_t stream;\n CUDA_ENFORCE(cudaStreamCreate(&stream));\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaStreamSynchronize(stream));\n }\n}\nBENCHMARK(BM_cudaStreamSynchronize);\n\nstatic void BM_cudaEventRecord(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n cudaStream_t stream;\n cudaEvent_t event;\n CUDA_ENFORCE(cudaStreamCreate(&stream));\n CUDA_ENFORCE(cudaEventCreateWithFlags(\n &event, cudaEventDefault | cudaEventDisableTiming));\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaEventRecord(event, stream));\n }\n}\nBENCHMARK(BM_cudaEventRecord);\n\nstatic void BM_cudaStreamWaitEventThenStreamSynchronize(\n benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n cudaStream_t stream;\n cudaEvent_t event;\n CUDA_ENFORCE(cudaStreamCreate(&stream));\n CUDA_ENFORCE(cudaEventCreateWithFlags(\n &event, cudaEventDefault | cudaEventDisableTiming));\n CUDA_ENFORCE(cudaEventRecord(event, stream));\n CUDA_ENFORCE(cudaStreamWaitEvent(stream, event, 0));\n CUDA_ENFORCE(cudaStreamSynchronize(stream));\n while (state.KeepRunning()) {\n CUDA_ENFORCE(cudaStreamWaitEvent(stream, event, 0));\n CUDA_ENFORCE(cudaStreamSynchronize(stream));\n }\n}\nBENCHMARK(BM_cudaStreamWaitEventThenStreamSynchronize);\n\nstatic void BM_CudaPointerAffinity(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n TensorCUDA tensor(vector{1, 2, 3, 4});\n float* ptr = tensor.mutable_data();\n while (state.KeepRunning()) {\n volatile int id = GetGPUIDForPointer(ptr);\n }\n}\nBENCHMARK(BM_CudaPointerAffinity);\n\nnamespace {\ntemplate \nclass DummyEmptyOp : public Operator {\n public:\n DummyEmptyOp(const OperatorDef& def, Workspace* ws)\n : Operator(def, ws) {}\n\n bool RunOnDevice() final { return true; }\n};\n\nREGISTER_CPU_OPERATOR(DummyEmpty, DummyEmptyOp);\nREGISTER_CUDA_OPERATOR(DummyEmpty, DummyEmptyOp);\nOPERATOR_SCHEMA(DummyEmpty);\n} // namespace\n\nstatic void BM_OperatorCreationCPU(benchmark::State& state) {\n std::unique_ptr op;\n OperatorDef def;\n Workspace ws;\n def.set_type(\"DummyEmpty\");\n def.mutable_device_option()->set_device_type(CPU);\n while (state.KeepRunning()) {\n op = CreateOperator(def, &ws);\n }\n}\nBENCHMARK(BM_OperatorCreationCPU);\n\nstatic void BM_OperatorCreationCUDA(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n std::unique_ptr op;\n OperatorDef def;\n Workspace ws;\n def.set_type(\"DummyEmpty\");\n def.mutable_device_option()->set_device_type(CUDA);\n while (state.KeepRunning()) {\n op = CreateOperator(def, &ws);\n }\n}\nBENCHMARK(BM_OperatorCreationCUDA);\n\nstatic void BM_RawAllocDeallocCPU(benchmark::State& state) {\n while (state.KeepRunning()) {\n // Allocating only 1 byte in order to measure the overhead.\n auto ptr_and_deleter = GetCPUAllocator()->New(1);\n // Deallocate.\n ptr_and_deleter.second(ptr_and_deleter.first);\n }\n}\nBENCHMARK(BM_RawAllocDeallocCPU);\n\nstatic void BM_TensorAllocDeallocCPU(benchmark::State& state) {\n Tensor tensor;\n // small allocation\n tensor.Resize(32, 32);\n while (state.KeepRunning()) {\n CHECK(tensor.mutable_data());\n tensor.FreeMemory();\n }\n}\nBENCHMARK(BM_TensorAllocDeallocCPU);\n\nstatic void BM_TensorAllocDeallocCUDA(benchmark::State& state) {\n CAFFE2_SKIP_IF_NO_GPU;\n Tensor tensor;\n // small allocation\n tensor.Resize(32, 32);\n while (state.KeepRunning()) {\n CHECK(tensor.mutable_data());\n tensor.FreeMemory();\n }\n}\nBENCHMARK(BM_TensorAllocDeallocCUDA);\n\nBENCHMARK_MAIN()\n" }, { "path": "binaries/db_throughput.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/timer.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(input_db, \"\", \"The input db.\");\nCAFFE2_DEFINE_string(input_db_type, \"\", \"The input db type.\");\nCAFFE2_DEFINE_int(report_interval, 1000, \"The report interval.\");\nCAFFE2_DEFINE_int(repeat, 10, \"The number to repeat the throughput test.\");\nCAFFE2_DEFINE_bool(use_reader, false, \"If true, use the reader interface.\");\nCAFFE2_DEFINE_int(num_read_threads, 1,\n \"The number of concurrent reading threads.\");\n\nusing caffe2::db::Cursor;\nusing caffe2::db::DB;\nusing caffe2::db::DBReader;\nusing caffe2::string;\n\nvoid TestThroughputWithDB() {\n std::unique_ptr in_db(caffe2::db::CreateDB(\n caffe2::FLAGS_input_db_type, caffe2::FLAGS_input_db, caffe2::db::READ));\n std::unique_ptr cursor(in_db->NewCursor());\n for (int iter_id = 0; iter_id < caffe2::FLAGS_repeat; ++iter_id) {\n caffe2::Timer timer;\n for (int i = 0; i < caffe2::FLAGS_report_interval; ++i) {\n string key = cursor->key();\n string value = cursor->value();\n //VLOG(1) << \"Key \" << key;\n cursor->Next();\n if (!cursor->Valid()) {\n cursor->SeekToFirst();\n }\n }\n double elapsed_seconds = timer.Seconds();\n printf(\"Iteration %03d, took %4.5f seconds, throughput %f items/sec.\\n\",\n iter_id, elapsed_seconds,\n caffe2::FLAGS_report_interval / elapsed_seconds);\n }\n}\n\nvoid TestThroughputWithReaderWorker(const DBReader* reader, int thread_id) {\n string key, value;\n for (int iter_id = 0; iter_id < caffe2::FLAGS_repeat; ++iter_id) {\n caffe2::Timer timer;\n for (int i = 0; i < caffe2::FLAGS_report_interval; ++i) {\n reader->Read(&key, &value);\n }\n double elapsed_seconds = timer.Seconds();\n printf(\"Thread %03d iteration %03d, took %4.5f seconds, \"\n \"throughput %f items/sec.\\n\",\n thread_id, iter_id, elapsed_seconds,\n caffe2::FLAGS_report_interval / elapsed_seconds);\n }\n}\n\nvoid TestThroughputWithReader() {\n caffe2::db::DBReader reader(\n caffe2::FLAGS_input_db_type, caffe2::FLAGS_input_db);\n std::vector> reading_threads(\n caffe2::FLAGS_num_read_threads);\n for (int i = 0; i < reading_threads.size(); ++i) {\n reading_threads[i].reset(new std::thread(\n TestThroughputWithReaderWorker, &reader, i));\n }\n for (int i = 0; i < reading_threads.size(); ++i) {\n reading_threads[i]->join();\n }\n}\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n if (caffe2::FLAGS_use_reader) {\n TestThroughputWithReader();\n } else {\n TestThroughputWithDB();\n }\n return 0;\n}\n" }, { "path": "binaries/inspect_gpus.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \n#include \n\n#include \"caffe2/core/common_gpu.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/logging.h\"\n\nusing std::vector;\n\nCAFFE2_DECLARE_int(caffe2_log_level);\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::SetUsageMessage(\n \"Inspects the GPUs on the current machine and prints out their details \"\n \"provided by cuda.\");\n\n int gpu_count;\n CUDA_ENFORCE(cudaGetDeviceCount(&gpu_count));\n for (int i = 0; i < gpu_count; ++i) {\n LOG(INFO) << \"Querying device ID = \" << i;\n caffe2::DeviceQuery(i);\n }\n\n vector > access_pattern;\n CAFFE_ENFORCE(caffe2::GetCudaPeerAccessPattern(&access_pattern));\n\n std::stringstream sstream;\n // Find topology\n for (int i = 0; i < gpu_count; ++i) {\n for (int j = 0; j < gpu_count; ++j) {\n sstream << (access_pattern[i][j] ? \"+\" : \"-\") << \" \";\n }\n sstream << std::endl;\n }\n LOG(INFO) << \"Access pattern: \" << std::endl << sstream.str();\n\n return 0;\n}\n" }, { "path": "binaries/make_cifar_db.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n//\n// This script converts the CIFAR dataset to the leveldb format used\n// by caffe to perform classification.\n// Usage:\n// convert_cifar_data input_folder output_db_file\n// The CIFAR dataset could be downloaded at\n// http://www.cs.toronto.edu/~kriz/cifar.html\n\n#include \n#include // NOLINT(readability/streams)\n#include \n#include \n\n#include \"caffe2/core/common.h\"\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(input_folder, \"\", \"The input folder name.\");\nCAFFE2_DEFINE_string(output_train_db_name,\n \"\", \"The output training db name.\");\nCAFFE2_DEFINE_string(output_test_db_name,\n \"\", \"The output testing db name.\");\nCAFFE2_DEFINE_string(db, \"leveldb\", \"The db type.\");\nCAFFE2_DEFINE_bool(is_cifar100, false,\n \"If set, convert cifar100. Otherwise do cifar10.\");\n\nnamespace caffe2 {\n\nusing std::stringstream;\n\nconst int kCIFARSize = 32;\nconst int kCIFARImageNBytes = kCIFARSize * kCIFARSize * 3;\nconst int kCIFAR10BatchSize = 10000;\nconst int kCIFAR10TestDataSize = 10000;\nconst int kCIFAR10TrainBatches = 5;\n\nconst int kCIFAR100TrainDataSize = 50000;\nconst int kCIFAR100TestDataSize = 10000;\n\nvoid ReadImage(std::ifstream* file, int* label, char* buffer) {\n char label_char;\n if (caffe2::FLAGS_is_cifar100) {\n // Skip the coarse label.\n file->read(&label_char, 1);\n }\n file->read(&label_char, 1);\n *label = label_char;\n // Yes, there are better ways to do it, like in-place swap... but I am too\n // lazy so let's just write it in a memory-wasteful way.\n std::array channel_first_storage;\n file->read(channel_first_storage.data(), kCIFARImageNBytes);\n for (int c = 0; c < 3; ++c) {\n for (int i = 0; i < kCIFARSize * kCIFARSize; ++i) {\n buffer[i * 3 + c] =\n channel_first_storage[c * kCIFARSize * kCIFARSize + i];\n }\n }\n return;\n}\n\nvoid WriteToDB(const string& filename, const int num_items,\n const int& offset, db::DB* db) {\n TensorProtos protos;\n TensorProto* data = protos.add_protos();\n TensorProto* label = protos.add_protos();\n data->set_data_type(TensorProto::BYTE);\n data->add_dims(kCIFARSize);\n data->add_dims(kCIFARSize);\n data->add_dims(3);\n label->set_data_type(TensorProto::INT32);\n label->add_dims(1);\n label->add_int32_data(0);\n\n LOG(INFO) << \"Converting file \" << filename;\n std::ifstream data_file(filename.c_str(),\n std::ios::in | std::ios::binary);\n CAFFE_ENFORCE(data_file, \"Unable to open file \", filename);\n char str_buffer[kCIFARImageNBytes];\n int label_value;\n string serialized_protos;\n std::unique_ptr transaction(db->NewTransaction());\n for (int itemid = 0; itemid < num_items; ++itemid) {\n ReadImage(&data_file, &label_value, str_buffer);\n data->set_byte_data(str_buffer, kCIFARImageNBytes);\n label->set_int32_data(0, label_value);\n protos.SerializeToString(&serialized_protos);\n snprintf(str_buffer, kCIFARImageNBytes, \"%05d\",\n offset + itemid);\n transaction->Put(string(str_buffer), serialized_protos);\n }\n}\n\nvoid ConvertCIFAR() {\n std::unique_ptr train_db(\n db::CreateDB(caffe2::FLAGS_db, caffe2::FLAGS_output_train_db_name,\n db::NEW));\n std::unique_ptr test_db(\n db::CreateDB(caffe2::FLAGS_db, caffe2::FLAGS_output_test_db_name,\n db::NEW));\n\n if (!caffe2::FLAGS_is_cifar100) {\n // This is cifar 10.\n for (int fileid = 0; fileid < kCIFAR10TrainBatches; ++fileid) {\n stringstream train_file;\n train_file << caffe2::FLAGS_input_folder << \"/data_batch_\" << fileid + 1\n << \".bin\";\n WriteToDB(train_file.str(), kCIFAR10BatchSize,\n fileid * kCIFAR10BatchSize, train_db.get());\n }\n stringstream test_file;\n test_file << caffe2::FLAGS_input_folder << \"/test_batch.bin\";\n WriteToDB(test_file.str(), kCIFAR10TestDataSize, 0, test_db.get());\n } else {\n // This is cifar 100.\n stringstream train_file;\n train_file << caffe2::FLAGS_input_folder << \"/train.bin\";\n WriteToDB(train_file.str(), kCIFAR100TrainDataSize, 0, train_db.get());\n stringstream test_file;\n test_file << caffe2::FLAGS_input_folder << \"/test.bin\";\n WriteToDB(test_file.str(), kCIFAR100TestDataSize, 0, test_db.get());\n }\n}\n\n} // namespace caffe2\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::ConvertCIFAR();\n return 0;\n}\n" }, { "path": "binaries/make_image_db.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// This script converts an image dataset to a database.\n//\n// caffe2::FLAGS_input_folder is the root folder that holds all the images\n//\n// caffe2::FLAGS_list_file is the path to a file containing a list of files\n// and their labels, as follows:\n//\n// subfolder1/file1.JPEG 7\n// subfolder1/file2.JPEG 7\n// subfolder2/file1.JPEG 8\n// ...\n//\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"caffe2/core/common.h\"\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_bool(shuffle, false,\n \"Randomly shuffle the order of images and their labels\");\nCAFFE2_DEFINE_string(input_folder, \"\", \"The input image file name.\");\nCAFFE2_DEFINE_string(\n list_file,\n \"\",\n \"The text file containing the list of images.\");\nCAFFE2_DEFINE_string(output_db_name, \"\", \"The output training leveldb name.\");\nCAFFE2_DEFINE_string(db, \"leveldb\", \"The db type.\");\nCAFFE2_DEFINE_bool(raw, false,\n \"If set, we pre-read the images and store the raw buffer.\");\nCAFFE2_DEFINE_bool(color, true, \"If set, load images in color.\");\nCAFFE2_DEFINE_int(\n scale,\n 256,\n \"If caffe2::FLAGS_raw is set, scale the shorter edge to the given value.\");\nCAFFE2_DEFINE_bool(warp, false, \"If warp is set, warp the images to square.\");\nCAFFE2_DEFINE_int(\n num_threads,\n -1,\n \"Number of image parsing and conversion threads.\");\n\nnamespace caffe2 {\n\nclass Converter {\n public:\n explicit Converter() {\n data_ = protos_.add_protos();\n label_ = protos_.add_protos();\n if (caffe2::FLAGS_raw) {\n data_->set_data_type(TensorProto::BYTE);\n data_->add_dims(0);\n data_->add_dims(0);\n if (caffe2::FLAGS_color) {\n data_->add_dims(3);\n }\n } else {\n data_->set_data_type(TensorProto::STRING);\n data_->add_dims(1);\n data_->add_string_data(\"\");\n }\n label_->set_data_type(TensorProto::INT32);\n label_->add_dims(1);\n label_->add_int32_data(0);\n }\n\n ~Converter() {\n if (thread_.joinable()) {\n thread_.join();\n }\n }\n\n void queue(const std::pair& pair) {\n in_.push(pair);\n }\n\n void start() {\n thread_ = std::thread(&Converter::run, this);\n }\n\n std::string get() {\n std::unique_lock lock(mutex_);\n while (out_.empty()) {\n cv_.wait(lock);\n }\n\n auto value = out_.front();\n out_.pop();\n cv_.notify_one();\n return value;\n }\n\n void run() {\n const auto& input_folder = caffe2::FLAGS_input_folder;\n std::unique_lock lock(mutex_);\n std::string value;\n while (!in_.empty()) {\n auto pair = in_.front();\n in_.pop();\n lock.unlock();\n\n label_->set_int32_data(0, pair.second);\n\n // Add raw file contents to DB if !raw\n if (!caffe2::FLAGS_raw) {\n std::ifstream image_file_stream(input_folder + pair.first);\n if (!image_file_stream) {\n LOG(ERROR) << \"Cannot open \" << input_folder << pair.first\n << \". Skipping.\";\n } else {\n data_->mutable_string_data(0)->assign(\n std::istreambuf_iterator(image_file_stream),\n std::istreambuf_iterator());\n }\n } else {\n // Load image\n cv::Mat img = cv::imread(\n input_folder + pair.first,\n caffe2::FLAGS_color ? CV_LOAD_IMAGE_COLOR\n : CV_LOAD_IMAGE_GRAYSCALE);\n\n // Resize image\n cv::Mat resized_img;\n int scaled_width, scaled_height;\n if (caffe2::FLAGS_warp) {\n scaled_width = caffe2::FLAGS_scale;\n scaled_height = caffe2::FLAGS_scale;\n } else if (img.rows > img.cols) {\n scaled_width = caffe2::FLAGS_scale;\n scaled_height =\n static_cast(img.rows) * caffe2::FLAGS_scale / img.cols;\n } else {\n scaled_height = caffe2::FLAGS_scale;\n scaled_width =\n static_cast(img.cols) * caffe2::FLAGS_scale / img.rows;\n }\n cv::resize(\n img,\n resized_img,\n cv::Size(scaled_width, scaled_height),\n 0,\n 0,\n cv::INTER_LINEAR);\n data_->set_dims(0, scaled_height);\n data_->set_dims(1, scaled_width);\n\n // Assert we don't have to deal with alignment\n DCHECK(resized_img.isContinuous());\n auto nbytes = resized_img.total() * resized_img.elemSize();\n data_->set_byte_data(resized_img.ptr(), nbytes);\n }\n\n protos_.SerializeToString(&value);\n\n // Add serialized proto to out queue or wait if it is not empty\n lock.lock();\n while (!out_.empty()) {\n cv_.wait(lock);\n }\n out_.push(value);\n cv_.notify_one();\n }\n }\n\n protected:\n TensorProtos protos_;\n TensorProto* data_;\n TensorProto* label_;\n std::queue> in_;\n std::queue out_;\n\n std::mutex mutex_;\n std::condition_variable cv_;\n std::thread thread_;\n};\n\nvoid ConvertImageDataset(\n const string& input_folder,\n const string& list_filename,\n const string& output_db_name,\n const bool /*shuffle*/) {\n std::ifstream list_file(list_filename);\n std::vector > lines;\n std::string filename;\n int file_label;\n while (list_file >> filename >> file_label) {\n lines.push_back(std::make_pair(filename, file_label));\n }\n\n if (caffe2::FLAGS_shuffle) {\n LOG(INFO) << \"Shuffling data\";\n std::shuffle(lines.begin(), lines.end(), std::default_random_engine(1701));\n }\n\n auto num_threads = caffe2::FLAGS_num_threads;\n if (num_threads < 1) {\n num_threads = std::thread::hardware_concurrency();\n }\n\n LOG(INFO) << \"Processing \" << lines.size() << \" images...\";\n LOG(INFO) << \"Opening DB \" << output_db_name;\n\n auto db = db::CreateDB(caffe2::FLAGS_db, output_db_name, db::NEW);\n auto transaction = db->NewTransaction();\n\n LOG(INFO) << \"Using \" << num_threads << \" processing threads...\";\n std::vector converters(num_threads);\n\n // Queue entries across converters\n for (auto i = 0; i < lines.size(); i++) {\n converters[i % converters.size()].queue(lines[i]);\n }\n\n // Start all converters\n for (auto& converter : converters) {\n converter.start();\n }\n\n constexpr auto key_max_length = 256;\n char key_cstr[key_max_length];\n string value;\n int count = 0;\n for (auto i = 0; i < lines.size(); i++) {\n // Get serialized proto for this entry\n auto value = converters[i % converters.size()].get();\n\n // Synthesize key for this entry\n auto key_len = snprintf(\n key_cstr, sizeof(key_cstr), \"%08d_%s\", i, lines[i].first.c_str());\n DCHECK_LE(key_len, sizeof(key_cstr));\n\n // Put in db\n transaction->Put(string(key_cstr), value);\n\n if (++count % 1000 == 0) {\n // Commit the current writes.\n transaction->Commit();\n LOG(INFO) << \"Processed \" << count << \" files.\";\n }\n }\n\n // Commit final transaction\n transaction->Commit();\n LOG(INFO) << \"Processed \" << count << \" files.\";\n}\n\n} // namespace caffe2\n\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::ConvertImageDataset(\n caffe2::FLAGS_input_folder, caffe2::FLAGS_list_file,\n caffe2::FLAGS_output_db_name, caffe2::FLAGS_shuffle);\n return 0;\n}\n" }, { "path": "binaries/make_mnist_db.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// This script converts the MNIST dataset to leveldb.\n// The MNIST dataset could be downloaded at\n// http://yann.lecun.com/exdb/mnist/\n\n#include // NOLINT(readability/streams)\n#include \n\n#include \"caffe2/core/common.h\"\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(image_file, \"\", \"The input image file name.\");\nCAFFE2_DEFINE_string(label_file, \"\", \"The label file name.\");\nCAFFE2_DEFINE_string(output_file, \"\", \"The output db name.\");\nCAFFE2_DEFINE_string(db, \"leveldb\", \"The db type.\");\nCAFFE2_DEFINE_int(data_limit, -1,\n \"If set, only output this number of data points.\");\nCAFFE2_DEFINE_bool(channel_first, false,\n \"If set, write the data as channel-first (CHW order) as the old \"\n \"Caffe does.\");\n\nnamespace caffe2 {\nuint32_t swap_endian(uint32_t val) {\n val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF);\n return (val << 16) | (val >> 16);\n}\n\nvoid convert_dataset(const char* image_filename, const char* label_filename,\n const char* db_path, const int data_limit) {\n // Open files\n std::ifstream image_file(image_filename, std::ios::in | std::ios::binary);\n std::ifstream label_file(label_filename, std::ios::in | std::ios::binary);\n CAFFE_ENFORCE(image_file, \"Unable to open file \", image_filename);\n CAFFE_ENFORCE(label_file, \"Unable to open file \", label_filename);\n // Read the magic and the meta data\n uint32_t magic;\n uint32_t num_items;\n uint32_t num_labels;\n uint32_t rows;\n uint32_t cols;\n\n image_file.read(reinterpret_cast(&magic), 4);\n magic = swap_endian(magic);\n if (magic == 529205256) {\n LOG(FATAL) << \n \"It seems that you forgot to unzip the mnist dataset. You should \"\n \"first unzip them using e.g. gunzip on Linux.\";\n }\n CAFFE_ENFORCE_EQ(magic, 2051, \"Incorrect image file magic.\");\n label_file.read(reinterpret_cast(&magic), 4);\n magic = swap_endian(magic);\n CAFFE_ENFORCE_EQ(magic, 2049, \"Incorrect label file magic.\");\n image_file.read(reinterpret_cast(&num_items), 4);\n num_items = swap_endian(num_items);\n label_file.read(reinterpret_cast(&num_labels), 4);\n num_labels = swap_endian(num_labels);\n CAFFE_ENFORCE_EQ(num_items, num_labels);\n image_file.read(reinterpret_cast(&rows), 4);\n rows = swap_endian(rows);\n image_file.read(reinterpret_cast(&cols), 4);\n cols = swap_endian(cols);\n\n // leveldb\n std::unique_ptr mnist_db(db::CreateDB(caffe2::FLAGS_db, db_path, db::NEW));\n std::unique_ptr transaction(mnist_db->NewTransaction());\n // Storing to db\n char label_value;\n std::vector pixels(rows * cols);\n int count = 0;\n const int kMaxKeyLength = 10;\n char key_cstr[kMaxKeyLength];\n string value;\n\n TensorProtos protos;\n TensorProto* data = protos.add_protos();\n TensorProto* label = protos.add_protos();\n data->set_data_type(TensorProto::BYTE);\n if (caffe2::FLAGS_channel_first) {\n data->add_dims(1);\n data->add_dims(rows);\n data->add_dims(cols);\n } else {\n data->add_dims(rows);\n data->add_dims(cols);\n data->add_dims(1);\n }\n label->set_data_type(TensorProto::INT32);\n label->add_int32_data(0);\n\n LOG(INFO) << \"A total of \" << num_items << \" items.\";\n LOG(INFO) << \"Rows: \" << rows << \" Cols: \" << cols;\n for (int item_id = 0; item_id < num_items; ++item_id) {\n image_file.read(pixels.data(), rows * cols);\n label_file.read(&label_value, 1);\n for (int i = 0; i < rows * cols; ++i) {\n data->set_byte_data(pixels.data(), rows * cols);\n }\n label->set_int32_data(0, static_cast(label_value));\n snprintf(key_cstr, kMaxKeyLength, \"%08d\", item_id);\n protos.SerializeToString(&value);\n string keystr(key_cstr);\n\n // Put in db\n transaction->Put(keystr, value);\n if (++count % 1000 == 0) {\n transaction->Commit();\n }\n if (data_limit > 0 && count == data_limit) {\n LOG(INFO) << \"Reached data limit of \" << data_limit << \", stop.\";\n break;\n }\n }\n}\n} // namespace caffe2\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::convert_dataset(caffe2::FLAGS_image_file.c_str(), caffe2::FLAGS_label_file.c_str(),\n caffe2::FLAGS_output_file.c_str(), caffe2::FLAGS_data_limit);\n return 0;\n}\n" }, { "path": "binaries/predictor_verifier.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"caffe2/core/flags.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/predictor.h\"\n#include \"caffe2/utils/proto_utils.h\"\n\nCAFFE2_DEFINE_string(init_net, \"\", \"The given path to the init protobuffer.\");\nCAFFE2_DEFINE_string(\n predict_net,\n \"\",\n \"The given path to the predict protobuffer.\");\n\nnamespace caffe2 {\n\nvoid run() {\n if (FLAGS_init_net.empty()) {\n LOG(FATAL) << \"No init net specified. Use --init_net=/path/to/net.\";\n }\n if (FLAGS_predict_net.empty()) {\n LOG(FATAL) << \"No predict net specified. Use --predict_net=/path/to/net.\";\n }\n caffe2::NetDef init_net, predict_net;\n CAFFE_ENFORCE(ReadProtoFromFile(FLAGS_init_net, &init_net));\n CAFFE_ENFORCE(ReadProtoFromFile(FLAGS_predict_net, &predict_net));\n // Can be large due to constant fills\n VLOG(1) << \"Init net: \" << ProtoDebugString(init_net);\n LOG(INFO) << \"Predict net: \" << ProtoDebugString(predict_net);\n auto predictor = caffe2::make_unique(init_net, predict_net);\n LOG(INFO) << \"Checking that a null forward-pass works\";\n Predictor::TensorVector inputVec, outputVec;\n predictor->run(inputVec, &outputVec);\n CAFFE_ENFORCE_GT(outputVec.size(), 0);\n}\n}\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::run();\n // This is to allow us to use memory leak checks.\n google::protobuf::ShutdownProtobufLibrary();\n return 0;\n}\n" }, { "path": "binaries/print_core_object_sizes.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/core/context.h\"\n#include \"caffe2/core/context_gpu.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n\n#define PRINT_SIZE(cls) \\\n std::cout << \"Size of \" #cls \": \" << sizeof(cls) << \" bytes.\" \\\n << std::endl;\n\nint main(int /* unused */, char** /* unused */) {\n PRINT_SIZE(caffe2::Blob);\n PRINT_SIZE(caffe2::Tensor);\n PRINT_SIZE(caffe2::Tensor);\n PRINT_SIZE(caffe2::CPUContext);\n PRINT_SIZE(caffe2::CUDAContext);\n PRINT_SIZE(caffe2::OperatorBase);\n PRINT_SIZE(caffe2::OperatorDef);\n PRINT_SIZE(caffe2::Operator);\n PRINT_SIZE(caffe2::Operator);\n PRINT_SIZE(caffe2::TypeMeta);\n PRINT_SIZE(caffe2::Workspace);\n return 0;\n}\n" }, { "path": "binaries/print_registered_core_operators.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/core/operator_schema.h\"\n\nCAFFE2_DEFINE_string(schema, \"\",\n \"Print doc and schema of a particular operator\");\n\nstatic bool HasSchema(const std::string& str) {\n return caffe2::OpSchemaRegistry::Schema(str);\n}\n\nstatic bool HasDoc(const std::string& str) {\n const auto* schema = caffe2::OpSchemaRegistry::Schema(str);\n return (schema != nullptr) && (schema->doc() != nullptr);\n}\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n\n if (!caffe2::FLAGS_schema.empty()) {\n const auto* schema = caffe2::OpSchemaRegistry::Schema(\n caffe2::FLAGS_schema);\n if (!schema) {\n std::cerr << \"Operator \" << caffe2::FLAGS_schema\n << \" doesn't have a schema\" << std::endl;\n return 1;\n }\n std::cout << \"Operator \" << caffe2::FLAGS_schema << \": \" << std::endl\n << *schema;\n return 0;\n }\n\n for (const auto& pair : *caffe2::gDeviceTypeRegistry()) {\n std::cout << \"Device type \" << pair.first\n#ifndef CAFFE2_USE_LITE_PROTO\n << \" (\" << caffe2::DeviceType_Name(\n static_cast(pair.first))\n << \")\"\n#endif\n << std::endl;\n for (const auto& key : pair.second->Keys()) {\n std::cout << \"\\t(schema: \" << HasSchema(key) << \", doc: \" << HasDoc(key)\n << \")\\t\" << key << std::endl;\n }\n }\n\n std::cout << \"Operators that have gradients registered:\" << std::endl;\n for (const auto& key : caffe2::GradientRegistry()->Keys()) {\n std::cout << \"\\t(schema: \" << HasSchema(key) << \", doc: \"\n << HasDoc(key) << \")\\t\"\n << key << std::endl;\n }\n return 0;\n}\n" }, { "path": "binaries/run_plan.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/utils/proto_utils.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(plan, \"\", \"The given path to the plan protobuffer.\");\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n if (caffe2::FLAGS_plan.size() == 0) {\n LOG(ERROR) << \"No plan specified. Use --plan=/path/to/plan.\";\n return 0;\n }\n LOG(INFO) << \"Loading plan: \" << caffe2::FLAGS_plan;\n caffe2::PlanDef plan_def;\n CAFFE_ENFORCE(ReadProtoFromFile(caffe2::FLAGS_plan, &plan_def));\n std::unique_ptr workspace(new caffe2::Workspace());\n workspace->RunPlan(plan_def);\n\n // This is to allow us to use memory leak checks.\n google::protobuf::ShutdownProtobufLibrary();\n return 0;\n}\n" }, { "path": "binaries/run_plan_mpi.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/utils/proto_utils.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(plan, \"\", \"The given path to the plan protobuffer.\");\n\nint main(int argc, char** argv) {\n caffe2::SetUsageMessage(\"Runs a caffe2 plan that has MPI operators in it.\");\n int mpi_ret;\n MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &mpi_ret);\n if (mpi_ret != MPI_THREAD_MULTIPLE &&\n mpi_ret != MPI_THREAD_SERIALIZED) {\n std::cerr << \"Caffe2 MPI requires the underlying MPI to support the \"\n \"MPI_THREAD_SERIALIZED or MPI_THREAD_MULTIPLE mode.\\n\";\n return 1;\n }\n caffe2::GlobalInit(&argc, &argv);\n LOG(INFO) << \"Loading plan: \" << caffe2::FLAGS_plan;\n caffe2::PlanDef plan_def;\n CAFFE_ENFORCE(ReadProtoFromFile(caffe2::FLAGS_plan, &plan_def));\n std::unique_ptr workspace(new caffe2::Workspace());\n workspace->RunPlan(plan_def);\n\n // This is to allow us to use memory leak checks.\n google::protobuf::ShutdownProtobufLibrary();\n MPI_Finalize();\n return 0;\n}\n" }, { "path": "binaries/speed_benchmark.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/logging.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/utils/proto_utils.h\"\n#include \"caffe2/utils/string_utils.h\"\n\nCAFFE2_DEFINE_string(net, \"\", \"The given net to benchmark.\");\nCAFFE2_DEFINE_string(\n init_net,\n \"\",\n \"The given net to initialize any parameters.\");\nCAFFE2_DEFINE_string(\n input,\n \"\",\n \"Input that is needed for running the network. If \"\n \"multiple input needed, use comma separated string.\");\nCAFFE2_DEFINE_string(\n input_file,\n \"\",\n \"Input file that contain the serialized protobuf for \"\n \"the input blobs. If multiple input needed, use comma \"\n \"separated string. Must have the same number of items \"\n \"as input does.\");\nCAFFE2_DEFINE_string(\n input_dims,\n \"\",\n \"Alternate to input_files, if all inputs are simple \"\n \"float TensorCPUs, specify the dimension using comma \"\n \"separated numbers. If multiple input needed, use \"\n \"semicolon to separate the dimension of different \"\n \"tensors.\");\nCAFFE2_DEFINE_string(\n output,\n \"\",\n \"Output that should be dumped after the execution \"\n \"finishes. If multiple outputs are needed, use comma \"\n \"separated string. If you want to dump everything, pass \"\n \"'*' as the output value.\");\nCAFFE2_DEFINE_string(\n output_folder,\n \"\",\n \"The folder that the output should be written to. This \"\n \"folder must already exist in the file system.\");\nCAFFE2_DEFINE_int(warmup, 0, \"The number of iterations to warm up.\");\nCAFFE2_DEFINE_int(iter, 10, \"The number of iterations to run.\");\nCAFFE2_DEFINE_bool(\n run_individual,\n false,\n \"Whether to benchmark individual operators.\");\n\nCAFFE2_DEFINE_bool(force_engine, false, \"Force engine field for all operators\");\nCAFFE2_DEFINE_string(engine, \"\", \"Forced engine field value\");\nCAFFE2_DEFINE_bool(force_algo, false, \"Force algo arg for all operators\");\nCAFFE2_DEFINE_string(algo, \"\", \"Forced algo arg value\");\n\nusing std::string;\nusing std::unique_ptr;\nusing std::vector;\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n unique_ptr workspace(new caffe2::Workspace());\n\n // Run initialization network.\n caffe2::NetDef net_def;\n CAFFE_ENFORCE(ReadProtoFromFile(caffe2::FLAGS_init_net, &net_def));\n CAFFE_ENFORCE(workspace->RunNetOnce(net_def));\n\n // Load input.\n if (caffe2::FLAGS_input.size()) {\n vector input_names = caffe2::split(',', caffe2::FLAGS_input);\n if (caffe2::FLAGS_input_file.size()) {\n vector input_files = caffe2::split(',', caffe2::FLAGS_input_file);\n CAFFE_ENFORCE_EQ(\n input_names.size(),\n input_files.size(),\n \"Input name and file should have the same number.\");\n for (int i = 0; i < input_names.size(); ++i) {\n caffe2::BlobProto blob_proto;\n CAFFE_ENFORCE(caffe2::ReadProtoFromFile(input_files[i], &blob_proto));\n workspace->CreateBlob(input_names[i])->Deserialize(blob_proto);\n }\n } else if (caffe2::FLAGS_input_dims.size()) {\n vector input_dims_list =\n caffe2::split(';', caffe2::FLAGS_input_dims);\n CAFFE_ENFORCE_EQ(\n input_names.size(),\n input_dims_list.size(),\n \"Input name and dims should have the same number of items.\");\n for (int i = 0; i < input_names.size(); ++i) {\n vector input_dims_str = caffe2::split(',', input_dims_list[i]);\n vector input_dims;\n for (const string& s : input_dims_str) {\n input_dims.push_back(caffe2::stoi(s));\n }\n caffe2::TensorCPU* tensor =\n workspace->GetBlob(input_names[i])->GetMutable();\n tensor->Resize(input_dims);\n tensor->mutable_data();\n }\n } else {\n CAFFE_THROW(\n \"You requested input tensors, but neither input_file nor \"\n \"input_dims is set.\");\n }\n }\n\n // Run main network.\n CAFFE_ENFORCE(ReadProtoFromFile(caffe2::FLAGS_net, &net_def));\n // force changing engine and algo\n if (caffe2::FLAGS_force_engine) {\n LOG(INFO) << \"force engine be: \" << caffe2::FLAGS_engine;\n for (const auto& op : net_def.op()) {\n const_cast(&op)->set_engine(caffe2::FLAGS_engine);\n }\n }\n if (caffe2::FLAGS_force_algo) {\n LOG(INFO) << \"force algo be: \" << caffe2::FLAGS_algo;\n for (const auto& op : net_def.op()) {\n caffe2::GetMutableArgument(\n \"algo\", true, const_cast(&op))\n ->set_s(caffe2::FLAGS_algo);\n }\n }\n caffe2::NetBase* net = workspace->CreateNet(net_def);\n CHECK_NOTNULL(net);\n net->TEST_Benchmark(\n caffe2::FLAGS_warmup, caffe2::FLAGS_iter, caffe2::FLAGS_run_individual);\n\n string output_prefix = caffe2::FLAGS_output_folder.size()\n ? caffe2::FLAGS_output_folder + \"/\"\n : \"\";\n if (caffe2::FLAGS_output.size()) {\n vector output_names = caffe2::split(',', caffe2::FLAGS_output);\n if (caffe2::FLAGS_output == \"*\") {\n output_names = workspace->Blobs();\n }\n for (const string& name : output_names) {\n CAFFE_ENFORCE(\n workspace->HasBlob(name),\n \"You requested a non-existing blob: \",\n name);\n string serialized = workspace->GetBlob(name)->Serialize(name);\n string output_filename = output_prefix + name;\n caffe2::WriteStringToFile(serialized, output_filename.c_str());\n }\n }\n\n return 0;\n}\n" }, { "path": "binaries/split_db.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/proto/caffe2.pb.h\"\n#include \"caffe2/core/logging.h\"\n\nCAFFE2_DEFINE_string(input_db, \"\", \"The input db.\");\nCAFFE2_DEFINE_int(splits, 0, \"The number of splits.\");\nCAFFE2_DEFINE_string(db_type, \"\", \"The db type.\");\nCAFFE2_DEFINE_int(batch_size, 1000, \"The write batch size.\");\n\nnamespace caffe2 {\n\nstatic int Split(int argc, char** argv) {\n GlobalInit(&argc, &argv);\n\n CAFFE_ENFORCE(FLAGS_input_db.size(), \"Must specify --input_db=/path/to/db.\");\n CAFFE_ENFORCE(FLAGS_splits > 0, \"Must specify a nonnegative split number.\");\n CAFFE_ENFORCE(FLAGS_db_type.size(), \"Must specify --db_type=[a db type].\");\n\n unique_ptr in_db(\n db::CreateDB(FLAGS_db_type, FLAGS_input_db, db::READ));\n CAFFE_ENFORCE(in_db != nullptr, \"Cannot open input db: \", FLAGS_input_db);\n unique_ptr cursor(in_db->NewCursor());\n // This usually won't happen, but FWIW.\n CAFFE_ENFORCE(\n cursor != nullptr, \"Cannot obtain cursor for input db: \", FLAGS_input_db);\n\n vector> out_dbs;\n vector> transactions;\n for (int i = 0; i < FLAGS_splits; ++i) {\n out_dbs.push_back(unique_ptr(db::CreateDB(\n FLAGS_db_type, FLAGS_input_db + \"_split_\" + to_string(i), db::NEW)));\n CAFFE_ENFORCE(out_dbs.back().get(), \"Cannot create output db #\", i);\n transactions.push_back(\n unique_ptr(out_dbs[i]->NewTransaction()));\n CAFFE_ENFORCE(\n transactions.back().get(), \"Cannot get transaction for output db #\", i);\n }\n\n int count = 0;\n for (; cursor->Valid(); cursor->Next()) {\n transactions[count % FLAGS_splits]->Put(cursor->key(), cursor->value());\n if (++count % FLAGS_batch_size == 0) {\n for (int i = 0; i < FLAGS_splits; ++i) {\n transactions[i]->Commit();\n }\n LOG(INFO) << \"Split \" << count << \" items so far.\";\n }\n }\n LOG(INFO) << \"A total of \" << count << \" items processed.\";\n return 0;\n}\n\n} // namespace caffe2\n\nint main(int argc, char** argv) {\n return caffe2::Split(argc, argv);\n}\n" }, { "path": "binaries/tutorial_blob.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"caffe2/core/blob.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/tensor.h\"\n#include \"caffe2/core/logging.h\"\n\n// We will be lazy and just use the whole namespace.\nusing namespace caffe2;\n\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n caffe2::ShowLogInfoToStderr();\n\n LOG(INFO) <<\n \"This script corresponds to the Blob part of the Caffe2 C++ \"\n \"tutorial.\";\n\n LOG(INFO) << \"Let's create a blob myblob.\";\n\n Blob myblob;\n\n LOG(INFO) << \"Let's set it to int and set the value to 10.\";\n\n int* myint = myblob.GetMutable();\n *myint = 10;\n\n LOG(INFO)\n << \"Is the blob type int? \"\n << myblob.IsType();\n\n LOG(INFO)\n << \"Is the blob type float? \"\n << myblob.IsType();\n \n const int& myint_const = myblob.Get();\n LOG(INFO)\n << \"The value of the int number stored in the blob is: \"\n << myint_const;\n\n LOG(INFO)\n << \"Let's try to get a float pointer. This will trigger an exception.\";\n\n try {\n const float& myfloat = myblob.Get();\n LOG(FATAL) << \"This line should never happen.\";\n } catch (std::exception& e) {\n LOG(INFO)\n << \"As expected, we got an exception. Its content says: \"\n << e.what();\n }\n\n LOG(INFO) <<\n \"However, we can change the content type (and destroy the old \"\n \"content) by calling GetMutable. Let's change it to double.\";\n\n double* mydouble = myblob.GetMutable();\n *mydouble = 3.14;\n\n LOG(INFO) << \"The new content is: \" << myblob.Get();\n\n LOG(INFO) <<\n \"If we have a pre-created object, we can use Reset() to transfer the \"\n \"object to a blob.\";\n\n std::string* pvec = new std::string();\n myblob.Reset(pvec); // no need to release pvec, myblob takes ownership.\n \n LOG(INFO) << \"Is the blob now of type string? \"\n << myblob.IsType();\n\n LOG(INFO) << \"This concludes the blob tutorial.\";\n return 0;\n}\n" }, { "path": "binaries/zmq_feeder.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// This binary provides an easy way to open a zeromq server and feeds data to\n// clients connect to it. It uses the Caffe2 db as the backend, thus allowing\n// one to convert any db-compliant storage to a zeromq service.\n\n#include \"caffe2/core/db.h\"\n#include \"caffe2/core/init.h\"\n#include \"caffe2/core/logging.h\"\n#include \"caffe2/utils/zmq_helper.h\"\n\nCAFFE2_DEFINE_string(server, \"tcp://*:5555\", \"The server address.\");\nCAFFE2_DEFINE_string(input_db, \"\", \"The input db.\");\nCAFFE2_DEFINE_string(input_db_type, \"\", \"The input db type.\");\n\nusing caffe2::db::DB;\nusing caffe2::db::Cursor;\nusing caffe2::string;\n\nint main(int argc, char** argv) {\n caffe2::GlobalInit(&argc, &argv);\n\n LOG(INFO) << \"Opening DB...\";\n auto in_db = caffe2::db::CreateDB(\n caffe2::FLAGS_input_db_type, caffe2::FLAGS_input_db, caffe2::db::READ);\n CAFFE_ENFORCE(\n in_db,\n \"Cannot load input db \" + caffe2::FLAGS_input_db + \" of expected type \" +\n caffe2::FLAGS_input_db_type);\n auto cursor = in_db->NewCursor();\n LOG(INFO) << \"DB opened.\";\n\n LOG(INFO) << \"Starting ZeroMQ server...\";\n\n // Socket to talk to clients\n caffe2::ZmqSocket sender(ZMQ_PUSH);\n sender.Bind(caffe2::FLAGS_server);\n LOG(INFO) << \"Server created at \" << caffe2::FLAGS_server;\n\n while (1) {\n VLOG(1) << \"Sending \" << cursor->key();\n sender.SendTillSuccess(cursor->key(), ZMQ_SNDMORE);\n sender.SendTillSuccess(cursor->value(), 0);\n cursor->Next();\n if (!cursor->Valid()) {\n cursor->SeekToFirst();\n }\n }\n // We do not do an elegant quit since this binary is going to be terminated by\n // control+C.\n return 0;\n}\n" }, { "path": "caffe/__init__.py", "content": "" }, { "path": "caffe/proto/CMakeLists.txt", "content": "file(GLOB Caffe_PROTOBUF_FILES \"${CMAKE_CURRENT_SOURCE_DIR}/*.proto\")\n\ncaffe2_protobuf_generate_cpp_py(Caffe_PROTO_SRCS Caffe_PROTO_HEADERS Caffe_PROTO_PY ${Caffe_PROTOBUF_FILES})\n\nadd_library(Caffe_PROTO OBJECT ${Caffe_PROTO_HEADERS} ${Caffe_PROTO_SRCS})\n\nif (MSVC)\n if(BUILD_SHARED_LIBS)\n set(Caffe2_API_DEFINE \"-DCAFFE2_API=__declspec(dllexport)\")\n else()\n set(Caffe2_API_DEFINE \"-DCAFFE2_API=\")\n endif()\n target_compile_definitions(\n Caffe_PROTO PRIVATE ${Caffe2_API_DEFINE})\nendif()\n\ninstall(FILES ${Caffe_PROTO_HEADERS} DESTINATION include/caffe/proto)\n" }, { "path": "caffe/proto/__init__.py", "content": "" }, { "path": "caffe/proto/caffe.proto", "content": "syntax = \"proto2\";\n\npackage caffe;\n\n// Specifies the shape (dimensions) of a Blob.\nmessage BlobShape {\n repeated int64 dim = 1 [packed = true];\n}\n\nmessage BlobProto {\n optional BlobShape shape = 7;\n repeated float data = 5 [packed = true];\n repeated float diff = 6 [packed = true];\n repeated double double_data = 8 [packed = true];\n repeated double double_diff = 9 [packed = true];\n\n // 4D dimensions -- deprecated. Use \"shape\" instead.\n optional int32 num = 1 [default = 0];\n optional int32 channels = 2 [default = 0];\n optional int32 height = 3 [default = 0];\n optional int32 width = 4 [default = 0];\n}\n\n// The BlobProtoVector is simply a way to pass multiple blobproto instances\n// around.\nmessage BlobProtoVector {\n repeated BlobProto blobs = 1;\n}\n\nmessage Datum {\n optional int32 channels = 1;\n optional int32 height = 2;\n optional int32 width = 3;\n // the actual image data, in bytes\n optional bytes data = 4;\n optional int32 label = 5;\n // Optionally, the datum could also hold float data.\n repeated float float_data = 6;\n // If true data contains an encoded image that need to be decoded\n optional bool encoded = 7 [default = false];\n}\n\nmessage FillerParameter {\n // The filler type.\n optional string type = 1 [default = 'constant'];\n optional float value = 2 [default = 0]; // the value in constant filler\n optional float min = 3 [default = 0]; // the min value in uniform filler\n optional float max = 4 [default = 1]; // the max value in uniform filler\n optional float mean = 5 [default = 0]; // the mean value in Gaussian filler\n optional float std = 6 [default = 1]; // the std value in Gaussian filler\n // The expected number of non-zero output weights for a given input in\n // Gaussian filler -- the default -1 means don't perform sparsification.\n optional int32 sparse = 7 [default = -1];\n // Normalize the filler variance by fan_in, fan_out, or their average.\n // Applies to 'xavier' and 'msra' fillers.\n enum VarianceNorm {\n FAN_IN = 0;\n FAN_OUT = 1;\n AVERAGE = 2;\n }\n optional VarianceNorm variance_norm = 8 [default = FAN_IN];\n}\n\nmessage NetParameter {\n optional string name = 1; // consider giving the network a name\n // DEPRECATED. See InputParameter. The input blobs to the network.\n repeated string input = 3;\n // DEPRECATED. See InputParameter. The shape of the input blobs.\n repeated BlobShape input_shape = 8;\n\n // 4D input dimensions -- deprecated. Use \"input_shape\" instead.\n // If specified, for each input blob there should be four\n // values specifying the num, channels, height and width of the input blob.\n // Thus, there should be a total of (4 * #input) numbers.\n repeated int32 input_dim = 4;\n\n // Whether the network will force every layer to carry out backward operation.\n // If set False, then whether to carry out backward is determined\n // automatically according to the net structure and learning rates.\n optional bool force_backward = 5 [default = false];\n // The current \"state\" of the network, including the phase, level, and stage.\n // Some layers may be included/excluded depending on this state and the states\n // specified in the layers' include and exclude fields.\n optional NetState state = 6;\n\n // Print debugging information about results while running Net::Forward,\n // Net::Backward, and Net::Update.\n optional bool debug_info = 7 [default = false];\n\n // The layers that make up the net. Each of their configurations, including\n // connectivity and behavior, is specified as a LayerParameter.\n repeated LayerParameter layer = 100; // ID 100 so layers are printed last.\n\n // DEPRECATED: use 'layer' instead.\n repeated V1LayerParameter layers = 2;\n}\n\n// NOTE\n// Update the next available ID when you add a new SolverParameter field.\n//\n// SolverParameter next available ID: 41 (last added: type)\nmessage SolverParameter {\n //////////////////////////////////////////////////////////////////////////////\n // Specifying the train and test networks\n //\n // Exactly one train net must be specified using one of the following fields:\n // train_net_param, train_net, net_param, net\n // One or more test nets may be specified using any of the following fields:\n // test_net_param, test_net, net_param, net\n // If more than one test net field is specified (e.g., both net and\n // test_net are specified), they will be evaluated in the field order given\n // above: (1) test_net_param, (2) test_net, (3) net_param/net.\n // A test_iter must be specified for each test_net.\n // A test_level and/or a test_stage may also be specified for each test_net.\n //////////////////////////////////////////////////////////////////////////////\n\n // Proto filename for the train net, possibly combined with one or more\n // test nets.\n optional string net = 24;\n // Inline train net param, possibly combined with one or more test nets.\n optional NetParameter net_param = 25;\n\n optional string train_net = 1; // Proto filename for the train net.\n repeated string test_net = 2; // Proto filenames for the test nets.\n optional NetParameter train_net_param = 21; // Inline train net params.\n repeated NetParameter test_net_param = 22; // Inline test net params.\n\n // The states for the train/test nets. Must be unspecified or\n // specified once per net.\n //\n // By default, all states will have solver = true;\n // train_state will have phase = TRAIN,\n // and all test_state's will have phase = TEST.\n // Other defaults are set according to the NetState defaults.\n optional NetState train_state = 26;\n repeated NetState test_state = 27;\n\n // The number of iterations for each test net.\n repeated int32 test_iter = 3;\n\n // The number of iterations between two testing phases.\n optional int32 test_interval = 4 [default = 0];\n optional bool test_compute_loss = 19 [default = false];\n // If true, run an initial test pass before the first iteration,\n // ensuring memory availability and printing the starting value of the loss.\n optional bool test_initialization = 32 [default = true];\n optional float base_lr = 5; // The base learning rate\n // the number of iterations between displaying info. If display = 0, no info\n // will be displayed.\n optional int32 display = 6;\n // Display the loss averaged over the last average_loss iterations\n optional int32 average_loss = 33 [default = 1];\n optional int32 max_iter = 7; // the maximum number of iterations\n // accumulate gradients over `iter_size` x `batch_size` instances\n optional int32 iter_size = 36 [default = 1];\n\n // The learning rate decay policy. The currently implemented learning rate\n // policies are as follows:\n // - fixed: always return base_lr.\n // - step: return base_lr * gamma ^ (floor(iter / step))\n // - exp: return base_lr * gamma ^ iter\n // - inv: return base_lr * (1 + gamma * iter) ^ (- power)\n // - multistep: similar to step but it allows non uniform steps defined by\n // stepvalue\n // - poly: the effective learning rate follows a polynomial decay, to be\n // zero by the max_iter. return base_lr (1 - iter/max_iter) ^ (power)\n // - sigmoid: the effective learning rate follows a sigmod decay\n // return base_lr ( 1/(1 + exp(-gamma * (iter - stepsize))))\n //\n // where base_lr, max_iter, gamma, step, stepvalue and power are defined\n // in the solver parameter protocol buffer, and iter is the current iteration.\n optional string lr_policy = 8;\n optional float gamma = 9; // The parameter to compute the learning rate.\n optional float power = 10; // The parameter to compute the learning rate.\n optional float momentum = 11; // The momentum value.\n optional float weight_decay = 12; // The weight decay.\n // regularization types supported: L1 and L2\n // controlled by weight_decay\n optional string regularization_type = 29 [default = \"L2\"];\n // the stepsize for learning rate policy \"step\"\n optional int32 stepsize = 13;\n // the stepsize for learning rate policy \"multistep\"\n repeated int32 stepvalue = 34;\n\n // Set clip_gradients to >= 0 to clip parameter gradients to that L2 norm,\n // whenever their actual L2 norm is larger.\n optional float clip_gradients = 35 [default = -1];\n\n optional int32 snapshot = 14 [default = 0]; // The snapshot interval\n optional string snapshot_prefix = 15; // The prefix for the snapshot.\n // whether to snapshot diff in the results or not. Snapshotting diff will help\n // debugging but the final protocol buffer size will be much larger.\n optional bool snapshot_diff = 16 [default = false];\n enum SnapshotFormat {\n HDF5 = 0;\n BINARYPROTO = 1;\n }\n optional SnapshotFormat snapshot_format = 37 [default = BINARYPROTO];\n // the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default.\n enum SolverMode {\n CPU = 0;\n GPU = 1;\n }\n optional SolverMode solver_mode = 17 [default = GPU];\n // the device_id will that be used in GPU mode. Use device_id = 0 in default.\n optional int32 device_id = 18 [default = 0];\n // If non-negative, the seed with which the Solver will initialize the Caffe\n // random number generator -- useful for reproducible results. Otherwise,\n // (and by default) initialize using a seed derived from the system clock.\n optional int64 random_seed = 20 [default = -1];\n\n // type of the solver\n optional string type = 40 [default = \"SGD\"];\n\n // numerical stability for RMSProp, AdaGrad and AdaDelta and Adam\n optional float delta = 31 [default = 1e-8];\n // parameters for the Adam solver\n optional float momentum2 = 39 [default = 0.999];\n\n // RMSProp decay value\n // MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t)\n optional float rms_decay = 38;\n\n // If true, print information about the state of the net that may help with\n // debugging learning problems.\n optional bool debug_info = 23 [default = false];\n\n // If false, don't save a snapshot after training finishes.\n optional bool snapshot_after_train = 28 [default = true];\n\n // DEPRECATED: old solver enum types, use string instead\n enum SolverType {\n SGD = 0;\n NESTEROV = 1;\n ADAGRAD = 2;\n RMSPROP = 3;\n ADADELTA = 4;\n ADAM = 5;\n }\n // DEPRECATED: use type instead of solver_type\n optional SolverType solver_type = 30 [default = SGD];\n}\n\n// A message that stores the solver snapshots\nmessage SolverState {\n optional int32 iter = 1; // The current iteration\n optional string learned_net = 2; // The file that stores the learned net.\n repeated BlobProto history = 3; // The history for sgd solvers\n optional int32 current_step = 4 [default = 0]; // The current step for learning rate\n}\n\nenum Phase {\n TRAIN = 0;\n TEST = 1;\n}\n\nmessage NetState {\n optional Phase phase = 1 [default = TEST];\n optional int32 level = 2 [default = 0];\n repeated string stage = 3;\n}\n\nmessage NetStateRule {\n // Set phase to require the NetState have a particular phase (TRAIN or TEST)\n // to meet this rule.\n optional Phase phase = 1;\n\n // Set the minimum and/or maximum levels in which the layer should be used.\n // Leave undefined to meet the rule regardless of level.\n optional int32 min_level = 2;\n optional int32 max_level = 3;\n\n // Customizable sets of stages to include or exclude.\n // The net must have ALL of the specified stages and NONE of the specified\n // \"not_stage\"s to meet the rule.\n // (Use multiple NetStateRules to specify conjunctions of stages.)\n repeated string stage = 4;\n repeated string not_stage = 5;\n}\n\n// Specifies training parameters (multipliers on global learning constants,\n// and the name and other settings used for weight sharing).\nmessage ParamSpec {\n // The names of the parameter blobs -- useful for sharing parameters among\n // layers, but never required otherwise. To share a parameter between two\n // layers, give it a (non-empty) name.\n optional string name = 1;\n\n // Whether to require shared weights to have the same shape, or just the same\n // count -- defaults to STRICT if unspecified.\n optional DimCheckMode share_mode = 2;\n enum DimCheckMode {\n // STRICT (default) requires that num, channels, height, width each match.\n STRICT = 0;\n // PERMISSIVE requires only the count (num*channels*height*width) to match.\n PERMISSIVE = 1;\n }\n\n // The multiplier on the global learning rate for this parameter.\n optional float lr_mult = 3 [default = 1.0];\n\n // The multiplier on the global weight decay for this parameter.\n optional float decay_mult = 4 [default = 1.0];\n}\n\n// NOTE\n// Update the next available ID when you add a new LayerParameter field.\n//\n// LayerParameter next available layer-specific ID: 147 (last added: recurrent_param)\nmessage LayerParameter {\n optional string name = 1; // the layer name\n optional string type = 2; // the layer type\n repeated string bottom = 3; // the name of each bottom blob\n repeated string top = 4; // the name of each top blob\n\n // The train / test phase for computation.\n optional Phase phase = 10;\n\n // The amount of weight to assign each top blob in the objective.\n // Each layer assigns a default value, usually of either 0 or 1,\n // to each top blob.\n repeated float loss_weight = 5;\n\n // Specifies training parameters (multipliers on global learning constants,\n // and the name and other settings used for weight sharing).\n repeated ParamSpec param = 6;\n\n // The blobs containing the numeric parameters of the layer.\n repeated BlobProto blobs = 7;\n\n // Specifies whether to backpropagate to each bottom. If unspecified,\n // Caffe will automatically infer whether each input needs backpropagation\n // to compute parameter gradients. If set to true for some inputs,\n // backpropagation to those inputs is forced; if set false for some inputs,\n // backpropagation to those inputs is skipped.\n //\n // The size must be either 0 or equal to the number of bottoms.\n repeated bool propagate_down = 11;\n\n // Rules controlling whether and when a layer is included in the network,\n // based on the current NetState. You may specify a non-zero number of rules\n // to include OR exclude, but not both. If no include or exclude rules are\n // specified, the layer is always included. If the current NetState meets\n // ANY (i.e., one or more) of the specified rules, the layer is\n // included/excluded.\n repeated NetStateRule include = 8;\n repeated NetStateRule exclude = 9;\n\n // Parameters for data pre-processing.\n optional TransformationParameter transform_param = 100;\n\n // Parameters shared by loss layers.\n optional LossParameter loss_param = 101;\n\n // Layer type-specific parameters.\n //\n // Note: certain layers may have more than one computational engine\n // for their implementation. These layers include an Engine type and\n // engine parameter for selecting the implementation.\n // The default for the engine is set by the ENGINE switch at compile-time.\n optional AccuracyParameter accuracy_param = 102;\n optional ArgMaxParameter argmax_param = 103;\n optional BatchNormParameter batch_norm_param = 139;\n optional BiasParameter bias_param = 141;\n optional ConcatParameter concat_param = 104;\n optional ContrastiveLossParameter contrastive_loss_param = 105;\n optional ConvolutionParameter convolution_param = 106;\n optional CropParameter crop_param = 144;\n optional DataParameter data_param = 107;\n optional DropoutParameter dropout_param = 108;\n optional DummyDataParameter dummy_data_param = 109;\n optional EltwiseParameter eltwise_param = 110;\n optional ELUParameter elu_param = 140;\n optional EmbedParameter embed_param = 137;\n optional ExpParameter exp_param = 111;\n optional FlattenParameter flatten_param = 135;\n optional HDF5DataParameter hdf5_data_param = 112;\n optional HDF5OutputParameter hdf5_output_param = 113;\n optional HingeLossParameter hinge_loss_param = 114;\n optional ImageDataParameter image_data_param = 115;\n optional InfogainLossParameter infogain_loss_param = 116;\n optional InnerProductParameter inner_product_param = 117;\n optional InputParameter input_param = 143;\n optional LogParameter log_param = 134;\n optional LRNParameter lrn_param = 118;\n optional MemoryDataParameter memory_data_param = 119;\n optional MVNParameter mvn_param = 120;\n optional ParameterParameter parameter_param = 145;\n optional PoolingParameter pooling_param = 121;\n optional PowerParameter power_param = 122;\n optional PReLUParameter prelu_param = 131;\n optional PythonParameter python_param = 130;\n optional RecurrentParameter recurrent_param = 146;\n optional ReductionParameter reduction_param = 136;\n optional ReLUParameter relu_param = 123;\n optional ReshapeParameter reshape_param = 133;\n optional ScaleParameter scale_param = 142;\n optional SigmoidParameter sigmoid_param = 124;\n optional SoftmaxParameter softmax_param = 125;\n optional SPPParameter spp_param = 132;\n optional SliceParameter slice_param = 126;\n optional TanHParameter tanh_param = 127;\n optional ThresholdParameter threshold_param = 128;\n optional TileParameter tile_param = 138;\n optional WindowDataParameter window_data_param = 129;\n}\n\n// Message that stores parameters used to apply transformation\n// to the data layer's data\nmessage TransformationParameter {\n // For data pre-processing, we can do simple scaling and subtracting the\n // data mean, if provided. Note that the mean subtraction is always carried\n // out before scaling.\n optional float scale = 1 [default = 1];\n // Specify if we want to randomly mirror data.\n optional bool mirror = 2 [default = false];\n // Specify if we would like to randomly crop an image.\n optional uint32 crop_size = 3 [default = 0];\n // mean_file and mean_value cannot be specified at the same time\n optional string mean_file = 4;\n // if specified can be repeated once (would substract it from all the channels)\n // or can be repeated the same number of times as channels\n // (would subtract them from the corresponding channel)\n repeated float mean_value = 5;\n // Force the decoded image to have 3 color channels.\n optional bool force_color = 6 [default = false];\n // Force the decoded image to have 1 color channels.\n optional bool force_gray = 7 [default = false];\n}\n\n// Message that stores parameters shared by loss layers\nmessage LossParameter {\n // If specified, ignore instances with the given label.\n optional int32 ignore_label = 1;\n // How to normalize the loss for loss layers that aggregate across batches,\n // spatial dimensions, or other dimensions. Currently only implemented in\n // SoftmaxWithLoss layer.\n enum NormalizationMode {\n // Divide by the number of examples in the batch times spatial dimensions.\n // Outputs that receive the ignore label will NOT be ignored in computing\n // the normalization factor.\n FULL = 0;\n // Divide by the total number of output locations that do not take the\n // ignore_label. If ignore_label is not set, this behaves like FULL.\n VALID = 1;\n // Divide by the batch size.\n BATCH_SIZE = 2;\n // Do not normalize the loss.\n NONE = 3;\n }\n optional NormalizationMode normalization = 3 [default = VALID];\n // Deprecated. Ignored if normalization is specified. If normalization\n // is not specified, then setting this to false will be equivalent to\n // normalization = BATCH_SIZE to be consistent with previous behavior.\n optional bool normalize = 2;\n}\n\n// Messages that store parameters used by individual layer types follow, in\n// alphabetical order.\n\nmessage AccuracyParameter {\n // When computing accuracy, count as correct by comparing the true label to\n // the top k scoring classes. By default, only compare to the top scoring\n // class (i.e. argmax).\n optional uint32 top_k = 1 [default = 1];\n\n // The \"label\" axis of the prediction blob, whose argmax corresponds to the\n // predicted label -- may be negative to index from the end (e.g., -1 for the\n // last axis). For example, if axis == 1 and the predictions are\n // (N x C x H x W), the label blob is expected to contain N*H*W ground truth\n // labels with integer values in {0, 1, ..., C-1}.\n optional int32 axis = 2 [default = 1];\n\n // If specified, ignore instances with the given label.\n optional int32 ignore_label = 3;\n}\n\nmessage ArgMaxParameter {\n // If true produce pairs (argmax, maxval)\n optional bool out_max_val = 1 [default = false];\n optional uint32 top_k = 2 [default = 1];\n // The axis along which to maximise -- may be negative to index from the\n // end (e.g., -1 for the last axis).\n // By default ArgMaxLayer maximizes over the flattened trailing dimensions\n // for each index of the first / num dimension.\n optional int32 axis = 3;\n}\n\nmessage ConcatParameter {\n // The axis along which to concatenate -- may be negative to index from the\n // end (e.g., -1 for the last axis). Other axes must have the\n // same dimension for all the bottom blobs.\n // By default, ConcatLayer concatenates blobs along the \"channels\" axis (1).\n optional int32 axis = 2 [default = 1];\n\n // DEPRECATED: alias for \"axis\" -- does not support negative indexing.\n optional uint32 concat_dim = 1 [default = 1];\n}\n\nmessage BatchNormParameter {\n // If false, accumulate global mean/variance values via a moving average. If\n // true, use those accumulated values instead of computing mean/variance\n // across the batch.\n optional bool use_global_stats = 1;\n // How much does the moving average decay each iteration?\n optional float moving_average_fraction = 2 [default = .999];\n // Small value to add to the variance estimate so that we don't divide by\n // zero.\n optional float eps = 3 [default = 1e-5];\n}\n\nmessage BiasParameter {\n // The first axis of bottom[0] (the first input Blob) along which to apply\n // bottom[1] (the second input Blob). May be negative to index from the end\n // (e.g., -1 for the last axis).\n //\n // For example, if bottom[0] is 4D with shape 100x3x40x60, the output\n // top[0] will have the same shape, and bottom[1] may have any of the\n // following shapes (for the given value of axis):\n // (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60\n // (axis == 1 == -3) 3; 3x40; 3x40x60\n // (axis == 2 == -2) 40; 40x60\n // (axis == 3 == -1) 60\n // Furthermore, bottom[1] may have the empty shape (regardless of the value of\n // \"axis\") -- a scalar bias.\n optional int32 axis = 1 [default = 1];\n\n // (num_axes is ignored unless just one bottom is given and the bias is\n // a learned parameter of the layer. Otherwise, num_axes is determined by the\n // number of axes by the second bottom.)\n // The number of axes of the input (bottom[0]) covered by the bias\n // parameter, or -1 to cover all axes of bottom[0] starting from `axis`.\n // Set num_axes := 0, to add a zero-axis Blob: a scalar.\n optional int32 num_axes = 2 [default = 1];\n\n // (filler is ignored unless just one bottom is given and the bias is\n // a learned parameter of the layer.)\n // The initialization for the learned bias parameter.\n // Default is the zero (0) initialization, resulting in the BiasLayer\n // initially performing the identity operation.\n optional FillerParameter filler = 3;\n}\n\nmessage ContrastiveLossParameter {\n // margin for dissimilar pair\n optional float margin = 1 [default = 1.0];\n // The first implementation of this cost did not exactly match the cost of\n // Hadsell et al 2006 -- using (margin - d^2) instead of (margin - d)^2.\n // legacy_version = false (the default) uses (margin - d)^2 as proposed in the\n // Hadsell paper. New models should probably use this version.\n // legacy_version = true uses (margin - d^2). This is kept to support /\n // reproduce existing models and results\n optional bool legacy_version = 2 [default = false];\n}\n\nmessage ConvolutionParameter {\n optional uint32 num_output = 1; // The number of outputs for the layer\n optional bool bias_term = 2 [default = true]; // whether to have bias terms\n\n // Pad, kernel size, and stride are all given as a single value for equal\n // dimensions in all spatial dimensions, or once per spatial dimension.\n repeated uint32 pad = 3; // The padding size; defaults to 0\n repeated uint32 kernel_size = 4; // The kernel size\n repeated uint32 stride = 6; // The stride; defaults to 1\n // Factor used to dilate the kernel, (implicitly) zero-filling the resulting\n // holes. (Kernel dilation is sometimes referred to by its use in the\n // algorithme à trous from Holschneider et al. 1987.)\n repeated uint32 dilation = 18; // The dilation; defaults to 1\n\n // For 2D convolution only, the *_h and *_w versions may also be used to\n // specify both spatial dimensions.\n optional uint32 pad_h = 9 [default = 0]; // The padding height (2D only)\n optional uint32 pad_w = 10 [default = 0]; // The padding width (2D only)\n optional uint32 kernel_h = 11; // The kernel height (2D only)\n optional uint32 kernel_w = 12; // The kernel width (2D only)\n optional uint32 stride_h = 13; // The stride height (2D only)\n optional uint32 stride_w = 14; // The stride width (2D only)\n\n optional uint32 group = 5 [default = 1]; // The group size for group conv\n\n optional FillerParameter weight_filler = 7; // The filler for the weight\n optional FillerParameter bias_filler = 8; // The filler for the bias\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 15 [default = DEFAULT];\n\n // The axis to interpret as \"channels\" when performing convolution.\n // Preceding dimensions are treated as independent inputs;\n // succeeding dimensions are treated as \"spatial\".\n // With (N, C, H, W) inputs, and axis == 1 (the default), we perform\n // N independent 2D convolutions, sliding C-channel (or (C/g)-channels, for\n // groups g>1) filters across the spatial axes (H, W) of the input.\n // With (N, C, D, H, W) inputs, and axis == 1, we perform\n // N independent 3D convolutions, sliding (C/g)-channels\n // filters across the spatial axes (D, H, W) of the input.\n optional int32 axis = 16 [default = 1];\n\n // Whether to force use of the general ND convolution, even if a specific\n // implementation for blobs of the appropriate number of spatial dimensions\n // is available. (Currently, there is only a 2D-specific convolution\n // implementation; for input blobs with num_axes != 2, this option is\n // ignored and the ND implementation will be used.)\n optional bool force_nd_im2col = 17 [default = false];\n}\n\nmessage CropParameter {\n // To crop, elements of the first bottom are selected to fit the dimensions\n // of the second, reference bottom. The crop is configured by\n // - the crop `axis` to pick the dimensions for cropping\n // - the crop `offset` to set the shift for all/each dimension\n // to align the cropped bottom with the reference bottom.\n // All dimensions up to but excluding `axis` are preserved, while\n // the dimensions including and trailing `axis` are cropped.\n // If only one `offset` is set, then all dimensions are offset by this amount.\n // Otherwise, the number of offsets must equal the number of cropped axes to\n // shift the crop in each dimension accordingly.\n // Note: standard dimensions are N,C,H,W so the default is a spatial crop,\n // and `axis` may be negative to index from the end (e.g., -1 for the last\n // axis).\n optional int32 axis = 1 [default = 2];\n repeated uint32 offset = 2;\n}\n\nmessage DataParameter {\n enum DB {\n LEVELDB = 0;\n LMDB = 1;\n }\n // Specify the data source.\n optional string source = 1;\n // Specify the batch size.\n optional uint32 batch_size = 4;\n // The rand_skip variable is for the data layer to skip a few data points\n // to avoid all asynchronous sgd clients to start at the same point. The skip\n // point would be set as rand_skip * rand(0,1). Note that rand_skip should not\n // be larger than the number of keys in the database.\n // DEPRECATED. Each solver accesses a different subset of the database.\n optional uint32 rand_skip = 7 [default = 0];\n optional DB backend = 8 [default = LEVELDB];\n // DEPRECATED. See TransformationParameter. For data pre-processing, we can do\n // simple scaling and subtracting the data mean, if provided. Note that the\n // mean subtraction is always carried out before scaling.\n optional float scale = 2 [default = 1];\n optional string mean_file = 3;\n // DEPRECATED. See TransformationParameter. Specify if we would like to randomly\n // crop an image.\n optional uint32 crop_size = 5 [default = 0];\n // DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror\n // data.\n optional bool mirror = 6 [default = false];\n // Force the encoded image to have 3 color channels\n optional bool force_encoded_color = 9 [default = false];\n // Prefetch queue (Number of batches to prefetch to host memory, increase if\n // data access bandwidth varies).\n optional uint32 prefetch = 10 [default = 4];\n}\n\nmessage DropoutParameter {\n optional float dropout_ratio = 1 [default = 0.5]; // dropout ratio\n}\n\n// DummyDataLayer fills any number of arbitrarily shaped blobs with random\n// (or constant) data generated by \"Fillers\" (see \"message FillerParameter\").\nmessage DummyDataParameter {\n // This layer produces N >= 1 top blobs. DummyDataParameter must specify 1 or N\n // shape fields, and 0, 1 or N data_fillers.\n //\n // If 0 data_fillers are specified, ConstantFiller with a value of 0 is used.\n // If 1 data_filler is specified, it is applied to all top blobs. If N are\n // specified, the ith is applied to the ith top blob.\n repeated FillerParameter data_filler = 1;\n repeated BlobShape shape = 6;\n\n // 4D dimensions -- deprecated. Use \"shape\" instead.\n repeated uint32 num = 2;\n repeated uint32 channels = 3;\n repeated uint32 height = 4;\n repeated uint32 width = 5;\n}\n\nmessage EltwiseParameter {\n enum EltwiseOp {\n PROD = 0;\n SUM = 1;\n MAX = 2;\n }\n optional EltwiseOp operation = 1 [default = SUM]; // element-wise operation\n repeated float coeff = 2; // blob-wise coefficient for SUM operation\n\n // Whether to use an asymptotically slower (for >2 inputs) but stabler method\n // of computing the gradient for the PROD operation. (No effect for SUM op.)\n optional bool stable_prod_grad = 3 [default = true];\n}\n\n// Message that stores parameters used by ELULayer\nmessage ELUParameter {\n // Described in:\n // Clevert, D.-A., Unterthiner, T., & Hochreiter, S. (2015). Fast and Accurate\n // Deep Network Learning by Exponential Linear Units (ELUs). arXiv\n optional float alpha = 1 [default = 1];\n}\n\n// Message that stores parameters used by EmbedLayer\nmessage EmbedParameter {\n optional uint32 num_output = 1; // The number of outputs for the layer\n // The input is given as integers to be interpreted as one-hot\n // vector indices with dimension num_input. Hence num_input should be\n // 1 greater than the maximum possible input value.\n optional uint32 input_dim = 2;\n\n optional bool bias_term = 3 [default = true]; // Whether to use a bias term\n optional FillerParameter weight_filler = 4; // The filler for the weight\n optional FillerParameter bias_filler = 5; // The filler for the bias\n\n}\n\n// Message that stores parameters used by ExpLayer\nmessage ExpParameter {\n // ExpLayer computes outputs y = base ^ (shift + scale * x), for base > 0.\n // Or if base is set to the default (-1), base is set to e,\n // so y = exp(shift + scale * x).\n optional float base = 1 [default = -1.0];\n optional float scale = 2 [default = 1.0];\n optional float shift = 3 [default = 0.0];\n}\n\n/// Message that stores parameters used by FlattenLayer\nmessage FlattenParameter {\n // The first axis to flatten: all preceding axes are retained in the output.\n // May be negative to index from the end (e.g., -1 for the last axis).\n optional int32 axis = 1 [default = 1];\n\n // The last axis to flatten: all following axes are retained in the output.\n // May be negative to index from the end (e.g., the default -1 for the last\n // axis).\n optional int32 end_axis = 2 [default = -1];\n}\n\n// Message that stores parameters used by HDF5DataLayer\nmessage HDF5DataParameter {\n // Specify the data source.\n optional string source = 1;\n // Specify the batch size.\n optional uint32 batch_size = 2;\n\n // Specify whether to shuffle the data.\n // If shuffle == true, the ordering of the HDF5 files is shuffled,\n // and the ordering of data within any given HDF5 file is shuffled,\n // but data between different files are not interleaved; all of a file's\n // data are output (in a random order) before moving onto another file.\n optional bool shuffle = 3 [default = false];\n}\n\nmessage HDF5OutputParameter {\n optional string file_name = 1;\n}\n\nmessage HingeLossParameter {\n enum Norm {\n L1 = 1;\n L2 = 2;\n }\n // Specify the Norm to use L1 or L2\n optional Norm norm = 1 [default = L1];\n}\n\nmessage ImageDataParameter {\n // Specify the data source.\n optional string source = 1;\n // Specify the batch size.\n optional uint32 batch_size = 4 [default = 1];\n // The rand_skip variable is for the data layer to skip a few data points\n // to avoid all asynchronous sgd clients to start at the same point. The skip\n // point would be set as rand_skip * rand(0,1). Note that rand_skip should not\n // be larger than the number of keys in the database.\n optional uint32 rand_skip = 7 [default = 0];\n // Whether or not ImageLayer should shuffle the list of files at every epoch.\n optional bool shuffle = 8 [default = false];\n // It will also resize images if new_height or new_width are not zero.\n optional uint32 new_height = 9 [default = 0];\n optional uint32 new_width = 10 [default = 0];\n // Specify if the images are color or gray\n optional bool is_color = 11 [default = true];\n // DEPRECATED. See TransformationParameter. For data pre-processing, we can do\n // simple scaling and subtracting the data mean, if provided. Note that the\n // mean subtraction is always carried out before scaling.\n optional float scale = 2 [default = 1];\n optional string mean_file = 3;\n // DEPRECATED. See TransformationParameter. Specify if we would like to randomly\n // crop an image.\n optional uint32 crop_size = 5 [default = 0];\n // DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror\n // data.\n optional bool mirror = 6 [default = false];\n optional string root_folder = 12 [default = \"\"];\n}\n\nmessage InfogainLossParameter {\n // Specify the infogain matrix source.\n optional string source = 1;\n}\n\nmessage InnerProductParameter {\n optional uint32 num_output = 1; // The number of outputs for the layer\n optional bool bias_term = 2 [default = true]; // whether to have bias terms\n optional FillerParameter weight_filler = 3; // The filler for the weight\n optional FillerParameter bias_filler = 4; // The filler for the bias\n\n // The first axis to be lumped into a single inner product computation;\n // all preceding axes are retained in the output.\n // May be negative to index from the end (e.g., -1 for the last axis).\n optional int32 axis = 5 [default = 1];\n // Specify whether to transpose the weight matrix or not.\n // If transpose == true, any operations will be performed on the transpose\n // of the weight matrix. The weight matrix itself is not going to be transposed\n // but rather the transfer flag of operations will be toggled accordingly.\n optional bool transpose = 6 [default = false];\n}\n\nmessage InputParameter {\n // This layer produces N >= 1 top blob(s) to be assigned manually.\n // Define N shapes to set a shape for each top.\n // Define 1 shape to set the same shape for every top.\n // Define no shape to defer to reshaping manually.\n repeated BlobShape shape = 1;\n}\n\n// Message that stores parameters used by LogLayer\nmessage LogParameter {\n // LogLayer computes outputs y = log_base(shift + scale * x), for base > 0.\n // Or if base is set to the default (-1), base is set to e,\n // so y = ln(shift + scale * x) = log_e(shift + scale * x)\n optional float base = 1 [default = -1.0];\n optional float scale = 2 [default = 1.0];\n optional float shift = 3 [default = 0.0];\n}\n\n// Message that stores parameters used by LRNLayer\nmessage LRNParameter {\n optional uint32 local_size = 1 [default = 5];\n optional float alpha = 2 [default = 1.];\n optional float beta = 3 [default = 0.75];\n enum NormRegion {\n ACROSS_CHANNELS = 0;\n WITHIN_CHANNEL = 1;\n }\n optional NormRegion norm_region = 4 [default = ACROSS_CHANNELS];\n optional float k = 5 [default = 1.];\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 6 [default = DEFAULT];\n}\n\nmessage MemoryDataParameter {\n optional uint32 batch_size = 1;\n optional uint32 channels = 2;\n optional uint32 height = 3;\n optional uint32 width = 4;\n}\n\nmessage MVNParameter {\n // This parameter can be set to false to normalize mean only\n optional bool normalize_variance = 1 [default = true];\n\n // This parameter can be set to true to perform DNN-like MVN\n optional bool across_channels = 2 [default = false];\n\n // Epsilon for not dividing by zero while normalizing variance\n optional float eps = 3 [default = 1e-9];\n}\n\nmessage ParameterParameter {\n optional BlobShape shape = 1;\n}\n\nmessage PoolingParameter {\n enum PoolMethod {\n MAX = 0;\n AVE = 1;\n STOCHASTIC = 2;\n }\n optional PoolMethod pool = 1 [default = MAX]; // The pooling method\n // Pad, kernel size, and stride are all given as a single value for equal\n // dimensions in height and width or as Y, X pairs.\n optional uint32 pad = 4 [default = 0]; // The padding size (equal in Y, X)\n optional uint32 pad_h = 9 [default = 0]; // The padding height\n optional uint32 pad_w = 10 [default = 0]; // The padding width\n optional uint32 kernel_size = 2; // The kernel size (square)\n optional uint32 kernel_h = 5; // The kernel height\n optional uint32 kernel_w = 6; // The kernel width\n optional uint32 stride = 3 [default = 1]; // The stride (equal in Y, X)\n optional uint32 stride_h = 7; // The stride height\n optional uint32 stride_w = 8; // The stride width\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 11 [default = DEFAULT];\n // If global_pooling then it will pool over the size of the bottom by doing\n // kernel_h = bottom->height and kernel_w = bottom->width\n optional bool global_pooling = 12 [default = false];\n}\n\nmessage PowerParameter {\n // PowerLayer computes outputs y = (shift + scale * x) ^ power.\n optional float power = 1 [default = 1.0];\n optional float scale = 2 [default = 1.0];\n optional float shift = 3 [default = 0.0];\n}\n\nmessage PythonParameter {\n optional string module = 1;\n optional string layer = 2;\n // This value is set to the attribute `param_str` of the `PythonLayer` object\n // in Python before calling the `setup()` method. This could be a number,\n // string, dictionary in Python dict format, JSON, etc. You may parse this\n // string in `setup` method and use it in `forward` and `backward`.\n optional string param_str = 3 [default = ''];\n // Whether this PythonLayer is shared among worker solvers during data parallelism.\n // If true, each worker solver sequentially run forward from this layer.\n // This value should be set true if you are using it as a data layer.\n optional bool share_in_parallel = 4 [default = false];\n}\n\n// Message that stores parameters used by RecurrentLayer\nmessage RecurrentParameter {\n // The dimension of the output (and usually hidden state) representation --\n // must be explicitly set to non-zero.\n optional uint32 num_output = 1 [default = 0];\n\n optional FillerParameter weight_filler = 2; // The filler for the weight\n optional FillerParameter bias_filler = 3; // The filler for the bias\n\n // Whether to enable displaying debug_info in the unrolled recurrent net.\n optional bool debug_info = 4 [default = false];\n\n // Whether to add as additional inputs (bottoms) the initial hidden state\n // blobs, and add as additional outputs (tops) the final timestep hidden state\n // blobs. The number of additional bottom/top blobs required depends on the\n // recurrent architecture -- e.g., 1 for RNNs, 2 for LSTMs.\n optional bool expose_hidden = 5 [default = false];\n}\n\n// Message that stores parameters used by ReductionLayer\nmessage ReductionParameter {\n enum ReductionOp {\n SUM = 1;\n ASUM = 2;\n SUMSQ = 3;\n MEAN = 4;\n }\n\n optional ReductionOp operation = 1 [default = SUM]; // reduction operation\n\n // The first axis to reduce to a scalar -- may be negative to index from the\n // end (e.g., -1 for the last axis).\n // (Currently, only reduction along ALL \"tail\" axes is supported; reduction\n // of axis M through N, where N < num_axes - 1, is unsupported.)\n // Suppose we have an n-axis bottom Blob with shape:\n // (d0, d1, d2, ..., d(m-1), dm, d(m+1), ..., d(n-1)).\n // If axis == m, the output Blob will have shape\n // (d0, d1, d2, ..., d(m-1)),\n // and the ReductionOp operation is performed (d0 * d1 * d2 * ... * d(m-1))\n // times, each including (dm * d(m+1) * ... * d(n-1)) individual data.\n // If axis == 0 (the default), the output Blob always has the empty shape\n // (count 1), performing reduction across the entire input --\n // often useful for creating new loss functions.\n optional int32 axis = 2 [default = 0];\n\n optional float coeff = 3 [default = 1.0]; // coefficient for output\n}\n\n// Message that stores parameters used by ReLULayer\nmessage ReLUParameter {\n // Allow non-zero slope for negative inputs to speed up optimization\n // Described in:\n // Maas, A. L., Hannun, A. Y., & Ng, A. Y. (2013). Rectifier nonlinearities\n // improve neural network acoustic models. In ICML Workshop on Deep Learning\n // for Audio, Speech, and Language Processing.\n optional float negative_slope = 1 [default = 0];\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 2 [default = DEFAULT];\n}\n\nmessage ReshapeParameter {\n // Specify the output dimensions. If some of the dimensions are set to 0,\n // the corresponding dimension from the bottom layer is used (unchanged).\n // Exactly one dimension may be set to -1, in which case its value is\n // inferred from the count of the bottom blob and the remaining dimensions.\n // For example, suppose we want to reshape a 2D blob \"input\" with shape 2 x 8:\n //\n // layer {\n // type: \"Reshape\" bottom: \"input\" top: \"output\"\n // reshape_param { ... }\n // }\n //\n // If \"input\" is 2D with shape 2 x 8, then the following reshape_param\n // specifications are all equivalent, producing a 3D blob \"output\" with shape\n // 2 x 2 x 4:\n //\n // reshape_param { shape { dim: 2 dim: 2 dim: 4 } }\n // reshape_param { shape { dim: 0 dim: 2 dim: 4 } }\n // reshape_param { shape { dim: 0 dim: 2 dim: -1 } }\n // reshape_param { shape { dim: 0 dim:-1 dim: 4 } }\n //\n optional BlobShape shape = 1;\n\n // axis and num_axes control the portion of the bottom blob's shape that are\n // replaced by (included in) the reshape. By default (axis == 0 and\n // num_axes == -1), the entire bottom blob shape is included in the reshape,\n // and hence the shape field must specify the entire output shape.\n //\n // axis may be non-zero to retain some portion of the beginning of the input\n // shape (and may be negative to index from the end; e.g., -1 to begin the\n // reshape after the last axis, including nothing in the reshape,\n // -2 to include only the last axis, etc.).\n //\n // For example, suppose \"input\" is a 2D blob with shape 2 x 8.\n // Then the following ReshapeLayer specifications are all equivalent,\n // producing a blob \"output\" with shape 2 x 2 x 4:\n //\n // reshape_param { shape { dim: 2 dim: 2 dim: 4 } }\n // reshape_param { shape { dim: 2 dim: 4 } axis: 1 }\n // reshape_param { shape { dim: 2 dim: 4 } axis: -3 }\n //\n // num_axes specifies the extent of the reshape.\n // If num_axes >= 0 (and axis >= 0), the reshape will be performed only on\n // input axes in the range [axis, axis+num_axes].\n // num_axes may also be -1, the default, to include all remaining axes\n // (starting from axis).\n //\n // For example, suppose \"input\" is a 2D blob with shape 2 x 8.\n // Then the following ReshapeLayer specifications are equivalent,\n // producing a blob \"output\" with shape 1 x 2 x 8.\n //\n // reshape_param { shape { dim: 1 dim: 2 dim: 8 } }\n // reshape_param { shape { dim: 1 dim: 2 } num_axes: 1 }\n // reshape_param { shape { dim: 1 } num_axes: 0 }\n //\n // On the other hand, these would produce output blob shape 2 x 1 x 8:\n //\n // reshape_param { shape { dim: 2 dim: 1 dim: 8 } }\n // reshape_param { shape { dim: 1 } axis: 1 num_axes: 0 }\n //\n optional int32 axis = 2 [default = 0];\n optional int32 num_axes = 3 [default = -1];\n}\n\nmessage ScaleParameter {\n // The first axis of bottom[0] (the first input Blob) along which to apply\n // bottom[1] (the second input Blob). May be negative to index from the end\n // (e.g., -1 for the last axis).\n //\n // For example, if bottom[0] is 4D with shape 100x3x40x60, the output\n // top[0] will have the same shape, and bottom[1] may have any of the\n // following shapes (for the given value of axis):\n // (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60\n // (axis == 1 == -3) 3; 3x40; 3x40x60\n // (axis == 2 == -2) 40; 40x60\n // (axis == 3 == -1) 60\n // Furthermore, bottom[1] may have the empty shape (regardless of the value of\n // \"axis\") -- a scalar multiplier.\n optional int32 axis = 1 [default = 1];\n\n // (num_axes is ignored unless just one bottom is given and the scale is\n // a learned parameter of the layer. Otherwise, num_axes is determined by the\n // number of axes by the second bottom.)\n // The number of axes of the input (bottom[0]) covered by the scale\n // parameter, or -1 to cover all axes of bottom[0] starting from `axis`.\n // Set num_axes := 0, to multiply with a zero-axis Blob: a scalar.\n optional int32 num_axes = 2 [default = 1];\n\n // (filler is ignored unless just one bottom is given and the scale is\n // a learned parameter of the layer.)\n // The initialization for the learned scale parameter.\n // Default is the unit (1) initialization, resulting in the ScaleLayer\n // initially performing the identity operation.\n optional FillerParameter filler = 3;\n\n // Whether to also learn a bias (equivalent to a ScaleLayer+BiasLayer, but\n // may be more efficient). Initialized with bias_filler (defaults to 0).\n optional bool bias_term = 4 [default = false];\n optional FillerParameter bias_filler = 5;\n}\n\nmessage SigmoidParameter {\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 1 [default = DEFAULT];\n}\n\nmessage SliceParameter {\n // The axis along which to slice -- may be negative to index from the end\n // (e.g., -1 for the last axis).\n // By default, SliceLayer concatenates blobs along the \"channels\" axis (1).\n optional int32 axis = 3 [default = 1];\n repeated uint32 slice_point = 2;\n\n // DEPRECATED: alias for \"axis\" -- does not support negative indexing.\n optional uint32 slice_dim = 1 [default = 1];\n}\n\n// Message that stores parameters used by SoftmaxLayer, SoftmaxWithLossLayer\nmessage SoftmaxParameter {\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 1 [default = DEFAULT];\n\n // The axis along which to perform the softmax -- may be negative to index\n // from the end (e.g., -1 for the last axis).\n // Any other axes will be evaluated as independent softmaxes.\n optional int32 axis = 2 [default = 1];\n}\n\nmessage TanHParameter {\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 1 [default = DEFAULT];\n}\n\n// Message that stores parameters used by TileLayer\nmessage TileParameter {\n // The index of the axis to tile.\n optional int32 axis = 1 [default = 1];\n\n // The number of copies (tiles) of the blob to output.\n optional int32 tiles = 2;\n}\n\n// Message that stores parameters used by ThresholdLayer\nmessage ThresholdParameter {\n optional float threshold = 1 [default = 0]; // Strictly positive values\n}\n\nmessage WindowDataParameter {\n // Specify the data source.\n optional string source = 1;\n // For data pre-processing, we can do simple scaling and subtracting the\n // data mean, if provided. Note that the mean subtraction is always carried\n // out before scaling.\n optional float scale = 2 [default = 1];\n optional string mean_file = 3;\n // Specify the batch size.\n optional uint32 batch_size = 4;\n // Specify if we would like to randomly crop an image.\n optional uint32 crop_size = 5 [default = 0];\n // Specify if we want to randomly mirror data.\n optional bool mirror = 6 [default = false];\n // Foreground (object) overlap threshold\n optional float fg_threshold = 7 [default = 0.5];\n // Background (non-object) overlap threshold\n optional float bg_threshold = 8 [default = 0.5];\n // Fraction of batch that should be foreground objects\n optional float fg_fraction = 9 [default = 0.25];\n // Amount of contextual padding to add around a window\n // (used only by the window_data_layer)\n optional uint32 context_pad = 10 [default = 0];\n // Mode for cropping out a detection window\n // warp: cropped window is warped to a fixed size and aspect ratio\n // square: the tightest square around the window is cropped\n optional string crop_mode = 11 [default = \"warp\"];\n // cache_images: will load all images in memory for faster access\n optional bool cache_images = 12 [default = false];\n // append root_folder to locate images\n optional string root_folder = 13 [default = \"\"];\n}\n\nmessage SPPParameter {\n enum PoolMethod {\n MAX = 0;\n AVE = 1;\n STOCHASTIC = 2;\n }\n optional uint32 pyramid_height = 1;\n optional PoolMethod pool = 2 [default = MAX]; // The pooling method\n enum Engine {\n DEFAULT = 0;\n CAFFE = 1;\n CUDNN = 2;\n }\n optional Engine engine = 6 [default = DEFAULT];\n}\n\n// DEPRECATED: use LayerParameter.\nmessage V1LayerParameter {\n repeated string bottom = 2;\n repeated string top = 3;\n optional string name = 4;\n repeated NetStateRule include = 32;\n repeated NetStateRule exclude = 33;\n enum LayerType {\n NONE = 0;\n ABSVAL = 35;\n ACCURACY = 1;\n ARGMAX = 30;\n BNLL = 2;\n CONCAT = 3;\n CONTRASTIVE_LOSS = 37;\n CONVOLUTION = 4;\n DATA = 5;\n DECONVOLUTION = 39;\n DROPOUT = 6;\n DUMMY_DATA = 32;\n EUCLIDEAN_LOSS = 7;\n ELTWISE = 25;\n EXP = 38;\n FLATTEN = 8;\n HDF5_DATA = 9;\n HDF5_OUTPUT = 10;\n HINGE_LOSS = 28;\n IM2COL = 11;\n IMAGE_DATA = 12;\n INFOGAIN_LOSS = 13;\n INNER_PRODUCT = 14;\n LRN = 15;\n MEMORY_DATA = 29;\n MULTINOMIAL_LOGISTIC_LOSS = 16;\n MVN = 34;\n POOLING = 17;\n POWER = 26;\n RELU = 18;\n SIGMOID = 19;\n SIGMOID_CROSS_ENTROPY_LOSS = 27;\n SILENCE = 36;\n SOFTMAX = 20;\n SOFTMAX_LOSS = 21;\n SPLIT = 22;\n SLICE = 33;\n TANH = 23;\n WINDOW_DATA = 24;\n THRESHOLD = 31;\n }\n optional LayerType type = 5;\n repeated BlobProto blobs = 6;\n repeated string param = 1001;\n repeated DimCheckMode blob_share_mode = 1002;\n enum DimCheckMode {\n STRICT = 0;\n PERMISSIVE = 1;\n }\n repeated float blobs_lr = 7;\n repeated float weight_decay = 8;\n repeated float loss_weight = 35;\n optional AccuracyParameter accuracy_param = 27;\n optional ArgMaxParameter argmax_param = 23;\n optional ConcatParameter concat_param = 9;\n optional ContrastiveLossParameter contrastive_loss_param = 40;\n optional ConvolutionParameter convolution_param = 10;\n optional DataParameter data_param = 11;\n optional DropoutParameter dropout_param = 12;\n optional DummyDataParameter dummy_data_param = 26;\n optional EltwiseParameter eltwise_param = 24;\n optional ExpParameter exp_param = 41;\n optional HDF5DataParameter hdf5_data_param = 13;\n optional HDF5OutputParameter hdf5_output_param = 14;\n optional HingeLossParameter hinge_loss_param = 29;\n optional ImageDataParameter image_data_param = 15;\n optional InfogainLossParameter infogain_loss_param = 16;\n optional InnerProductParameter inner_product_param = 17;\n optional LRNParameter lrn_param = 18;\n optional MemoryDataParameter memory_data_param = 22;\n optional MVNParameter mvn_param = 34;\n optional PoolingParameter pooling_param = 19;\n optional PowerParameter power_param = 21;\n optional ReLUParameter relu_param = 30;\n optional SigmoidParameter sigmoid_param = 38;\n optional SoftmaxParameter softmax_param = 39;\n optional SliceParameter slice_param = 31;\n optional TanHParameter tanh_param = 37;\n optional ThresholdParameter threshold_param = 25;\n optional WindowDataParameter window_data_param = 20;\n optional TransformationParameter transform_param = 36;\n optional LossParameter loss_param = 42;\n optional V0LayerParameter layer = 1;\n}\n\n// DEPRECATED: V0LayerParameter is the old way of specifying layer parameters\n// in Caffe. We keep this message type around for legacy support.\nmessage V0LayerParameter {\n optional string name = 1; // the layer name\n optional string type = 2; // the string to specify the layer type\n\n // Parameters to specify layers with inner products.\n optional uint32 num_output = 3; // The number of outputs for the layer\n optional bool biasterm = 4 [default = true]; // whether to have bias terms\n optional FillerParameter weight_filler = 5; // The filler for the weight\n optional FillerParameter bias_filler = 6; // The filler for the bias\n\n optional uint32 pad = 7 [default = 0]; // The padding size\n optional uint32 kernelsize = 8; // The kernel size\n optional uint32 group = 9 [default = 1]; // The group size for group conv\n optional uint32 stride = 10 [default = 1]; // The stride\n enum PoolMethod {\n MAX = 0;\n AVE = 1;\n STOCHASTIC = 2;\n }\n optional PoolMethod pool = 11 [default = MAX]; // The pooling method\n optional float dropout_ratio = 12 [default = 0.5]; // dropout ratio\n\n optional uint32 local_size = 13 [default = 5]; // for local response norm\n optional float alpha = 14 [default = 1.]; // for local response norm\n optional float beta = 15 [default = 0.75]; // for local response norm\n optional float k = 22 [default = 1.];\n\n // For data layers, specify the data source\n optional string source = 16;\n // For data pre-processing, we can do simple scaling and subtracting the\n // data mean, if provided. Note that the mean subtraction is always carried\n // out before scaling.\n optional float scale = 17 [default = 1];\n optional string meanfile = 18;\n // For data layers, specify the batch size.\n optional uint32 batchsize = 19;\n // For data layers, specify if we would like to randomly crop an image.\n optional uint32 cropsize = 20 [default = 0];\n // For data layers, specify if we want to randomly mirror data.\n optional bool mirror = 21 [default = false];\n\n // The blobs containing the numeric parameters of the layer\n repeated BlobProto blobs = 50;\n // The ratio that is multiplied on the global learning rate. If you want to\n // set the learning ratio for one blob, you need to set it for all blobs.\n repeated float blobs_lr = 51;\n // The weight decay that is multiplied on the global weight decay.\n repeated float weight_decay = 52;\n\n // The rand_skip variable is for the data layer to skip a few data points\n // to avoid all asynchronous sgd clients to start at the same point. The skip\n // point would be set as rand_skip * rand(0,1). Note that rand_skip should not\n // be larger than the number of keys in the database.\n optional uint32 rand_skip = 53 [default = 0];\n\n // Fields related to detection (det_*)\n // foreground (object) overlap threshold\n optional float det_fg_threshold = 54 [default = 0.5];\n // background (non-object) overlap threshold\n optional float det_bg_threshold = 55 [default = 0.5];\n // Fraction of batch that should be foreground objects\n optional float det_fg_fraction = 56 [default = 0.25];\n\n // optional bool OBSOLETE_can_clobber = 57 [default = true];\n\n // Amount of contextual padding to add around a window\n // (used only by the window_data_layer)\n optional uint32 det_context_pad = 58 [default = 0];\n\n // Mode for cropping out a detection window\n // warp: cropped window is warped to a fixed size and aspect ratio\n // square: the tightest square around the window is cropped\n optional string det_crop_mode = 59 [default = \"warp\"];\n\n // For ReshapeLayer, one needs to specify the new dimensions.\n optional int32 new_num = 60 [default = 0];\n optional int32 new_channels = 61 [default = 0];\n optional int32 new_height = 62 [default = 0];\n optional int32 new_width = 63 [default = 0];\n\n // Whether or not ImageLayer should shuffle the list of files at every epoch.\n // It will also resize images if new_height or new_width are not zero.\n optional bool shuffle_images = 64 [default = false];\n\n // For ConcatLayer, one needs to specify the dimension for concatenation, and\n // the other dimensions must be the same for all the bottom blobs.\n // By default it will concatenate blobs along the channels dimension.\n optional uint32 concat_dim = 65 [default = 1];\n\n optional HDF5OutputParameter hdf5_output_param = 1001;\n}\n\nmessage PReLUParameter {\n // Parametric ReLU described in K. He et al, Delving Deep into Rectifiers:\n // Surpassing Human-Level Performance on ImageNet Classification, 2015.\n\n // Initial value of a_i. Default is a_i=0.25 for all i.\n optional FillerParameter filler = 1;\n // Whether or not slope paramters are shared across channels.\n optional bool channel_shared = 2 [default = false];\n}\n" }, { "path": "caffe2/.clang-format", "content": "---\nAccessModifierOffset: -1\nAlignAfterOpenBracket: AlwaysBreak\nAlignConsecutiveAssignments: false\nAlignConsecutiveDeclarations: false\nAlignEscapedNewlinesLeft: true\nAlignOperands: false\nAlignTrailingComments: false\nAllowAllParametersOfDeclarationOnNextLine: false\nAllowShortBlocksOnASingleLine: false\nAllowShortCaseLabelsOnASingleLine: false\nAllowShortFunctionsOnASingleLine: Empty\nAllowShortIfStatementsOnASingleLine: false\nAllowShortLoopsOnASingleLine: false\nAlwaysBreakAfterReturnType: None\nAlwaysBreakBeforeMultilineStrings: true\nAlwaysBreakTemplateDeclarations: true\nBinPackArguments: false\nBinPackParameters: false\nBraceWrapping:\n AfterClass: false\n AfterControlStatement: false\n AfterEnum: false\n AfterFunction: false\n AfterNamespace: false\n AfterObjCDeclaration: false\n AfterStruct: false\n AfterUnion: false\n BeforeCatch: false\n BeforeElse: false\n IndentBraces: false\nBreakBeforeBinaryOperators: None\nBreakBeforeBraces: Attach\nBreakBeforeTernaryOperators: true\nBreakConstructorInitializersBeforeComma: false\nBreakAfterJavaFieldAnnotations: false\nBreakStringLiterals: false\nColumnLimit: 80\nCommentPragmas: '^ IWYU pragma:'\nConstructorInitializerAllOnOneLineOrOnePerLine: true\nConstructorInitializerIndentWidth: 4\nContinuationIndentWidth: 4\nCpp11BracedListStyle: true\nDerivePointerAlignment: false\nDisableFormat: false\nForEachMacros: [ FOR_EACH_RANGE, FOR_EACH, ]\nIncludeCategories:\n - Regex: '^<.*\\.h(pp)?>'\n Priority: 1\n - Regex: '^<.*'\n Priority: 2\n - Regex: '.*'\n Priority: 3\nIndentCaseLabels: true\nIndentWidth: 2\nIndentWrappedFunctionNames: false\nKeepEmptyLinesAtTheStartOfBlocks: false\nMacroBlockBegin: ''\nMacroBlockEnd: ''\nMaxEmptyLinesToKeep: 1\nNamespaceIndentation: None\nObjCBlockIndentWidth: 2\nObjCSpaceAfterProperty: false\nObjCSpaceBeforeProtocolList: false\nPenaltyBreakBeforeFirstCallParameter: 1\nPenaltyBreakComment: 300\nPenaltyBreakFirstLessLess: 120\nPenaltyBreakString: 1000\nPenaltyExcessCharacter: 1000000\nPenaltyReturnTypeOnItsOwnLine: 200\nPointerAlignment: Left\nReflowComments: true\nSortIncludes: true\nSpaceAfterCStyleCast: false\nSpaceBeforeAssignmentOperators: true\nSpaceBeforeParens: ControlStatements\nSpaceInEmptyParentheses: false\nSpacesBeforeTrailingComments: 1\nSpacesInAngles: false\nSpacesInContainerLiterals: true\nSpacesInCStyleCastParentheses: false\nSpacesInParentheses: false\nSpacesInSquareBrackets: false\nStandard: Cpp11\nTabWidth: 8\nUseTab: Never\n...\n" }, { "path": "caffe2/CMakeLists.txt", "content": "# ---[ Declare source file lists\n\n# ---[ Add respective subdirectories\n# Note: the folders that are being commented out have not been properly\n# addressed yet.\n\nadd_subdirectory(proto)\n\nadd_subdirectory(contrib)\nadd_subdirectory(core)\nadd_subdirectory(cuda_rtc)\nadd_subdirectory(db)\nadd_subdirectory(distributed)\n# add_subdirectory(experiments) # note, we may remove this folder at some point\nadd_subdirectory(image)\nadd_subdirectory(video)\nadd_subdirectory(mkl)\nadd_subdirectory(mobile)\nadd_subdirectory(mpi)\nadd_subdirectory(observers)\nadd_subdirectory(onnx)\nadd_subdirectory(operators)\nadd_subdirectory(perfkernels)\nadd_subdirectory(python)\nadd_subdirectory(queue)\nadd_subdirectory(sgd)\nadd_subdirectory(share)\n# add_subdirectory(test) # todo: use caffe2_gtest_main instead of gtest_main because we will need to call GlobalInit\nadd_subdirectory(transforms)\nadd_subdirectory(utils)\n\n# Advanced: if we have white list specified, we will do intersections for all\n# main lib srcs.\nif (CAFFE2_WHITELISTED_FILES)\n caffe2_do_whitelist(Caffe2_CPU_SRCS CAFFE2_WHITELISTED_FILES)\n caffe2_do_whitelist(Caffe2_GPU_SRCS CAFFE2_WHITELISTED_FILES)\nendif()\n\n# Debug messages - if you want to get a list of source files, enable the\n# following.\nif (FALSE)\n message(STATUS \"CPU sources: \")\n foreach(tmp ${Caffe2_CPU_SRCS})\n message(STATUS \" \" ${tmp})\n endforeach()\n\n message(STATUS \"GPU sources: \")\n foreach(tmp ${Caffe2_GPU_SRCS})\n message(STATUS \" \" ${tmp})\n endforeach()\n\n message(STATUS \"CPU test sources: \")\n foreach(tmp ${Caffe2_CPU_TEST_SRCS})\n message(STATUS \" \" ${tmp})\n endforeach()\n\n message(STATUS \"GPU test sources: \")\n foreach(tmp ${Caffe2_GPU_TEST_SRCS})\n message(STATUS \" \" ${tmp})\n endforeach()\nendif()\n\n# ---[ Generate and install header files.\n\n# Write the macros file.\nconfigure_file(\n ${PROJECT_SOURCE_DIR}/caffe2/core/macros.h.in\n ${PROJECT_BINARY_DIR}/caffe2/core/macros.h)\n\n# Installing the header files\ninstall(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}\n DESTINATION include\n FILES_MATCHING PATTERN \"*.h\")\ninstall(FILES ${PROJECT_BINARY_DIR}/caffe2/core/macros.h\n DESTINATION include/caffe2/core)\n\n\n# ---[ List of libraries to link with\n\n# Compile exposed libraries.\nadd_library(caffe2 ${Caffe2_CPU_SRCS} $ $)\nadd_dependencies(caffe2 Caffe_PROTO Caffe2_PROTO)\ntarget_link_libraries(caffe2 PUBLIC ${Caffe2_PUBLIC_DEPENDENCY_LIBS})\ntarget_link_libraries(caffe2 PRIVATE ${Caffe2_DEPENDENCY_LIBS})\ntarget_link_libraries(caffe2 PRIVATE ${Caffe2_DEPENDENCY_WHOLE_LINK_LIBS})\ntarget_include_directories(caffe2 INTERFACE $)\ntarget_compile_options(caffe2 INTERFACE \"-std=c++11\")\ntarget_compile_options(caffe2 PRIVATE \"-DCAFFE2_BUILD_MAIN_LIB\")\ninstall(TARGETS caffe2 EXPORT Caffe2Targets DESTINATION lib)\ncaffe2_interface_library(caffe2 caffe2_library)\nlist(APPEND Caffe2_MAIN_LIBS caffe2_library)\n\n# ---[ CUDA library.\nif(USE_CUDA)\n # A hack to deal with cuda library dependencies and modern CMake: the\n # CUDA_ADD_LIBRARY includes a target_link_libraries, and as a result,\n # one cannot use PUBLIC/PRIVATE/INTERFACE for the target anymore. This\n # hack adds the PRIVATE keywords to CUDA_LIBRARIES so we can deal with\n # it. We will then manually add the cudart library as interface libs.\n set(__tmp ${CUDA_LIBRARIES})\n set(CUDA_LIBRARIES PRIVATE ${CUDA_LIBRARIES})\n CUDA_ADD_LIBRARY(caffe2_gpu ${Caffe2_GPU_SRCS})\n set(CUDA_LIBRARIES ${__tmp})\n target_link_libraries(caffe2_gpu INTERFACE caffe2::cudart)\n\n target_include_directories(\n caffe2_gpu INTERFACE $)\n target_link_libraries(\n caffe2_gpu PUBLIC caffe2 ${Caffe2_PUBLIC_CUDA_DEPENDENCY_LIBS})\n target_link_libraries(\n caffe2_gpu PRIVATE ${Caffe2_CUDA_DEPENDENCY_LIBS})\n caffe2_interface_library(caffe2_gpu caffe2_gpu_library)\n list(APPEND Caffe2_MAIN_LIBS caffe2_gpu_library)\n install(TARGETS caffe2_gpu EXPORT Caffe2Targets DESTINATION lib)\nendif()\n\n# ---[ Test binaries.\nif (BUILD_TEST)\n set(Caffe2_ALL_TEST_SRCS ${Caffe2_CPU_TEST_SRCS})\n if (USE_CUDA)\n list(APPEND Caffe2_ALL_TEST_SRCS ${Caffe2_GPU_TEST_SRCS})\n endif()\n\n foreach(test_src ${Caffe2_ALL_TEST_SRCS})\n get_filename_component(test_name ${test_src} NAME_WE)\n add_executable(${test_name} \"${test_src}\")\n # For tests, some of the test code actually directly call the dependent\n # libraries even if they are not part of the public dependency libs. As a\n # result, we will explicitly link the test against the Caffe2 dependency\n # libs.\n target_link_libraries(${test_name} ${Caffe2_MAIN_LIBS} gtest_main)\n if (USE_CUDA)\n target_link_libraries(${test_name} ${Caffe2_CUDA_DEPENDENCY_LIBS})\n endif()\n if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.0)\n target_compile_features(${test_name} PRIVATE cxx_range_for)\n endif()\n add_test(NAME ${test_name} COMMAND $)\n install(TARGETS ${test_name} DESTINATION test)\n endforeach()\nendif()\n\n\nif (BUILD_PYTHON)\n # Python site-packages\n # Get canonical directory for python site packages (relative to install\n # location). It varys from system to system.\n pycmd(PYTHON_SITE_PACKAGES \"\n from distutils import sysconfig\n print(sysconfig.get_python_lib(prefix=''))\n \")\n # ---[ Options.\n SET(PYTHON_LIB_REL_PATH \"${PYTHON_SITE_PACKAGES}\" CACHE STRING \"Python installation path (relative to CMake installation prefix)\")\n message(STATUS \"Using ${PYTHON_LIB_REL_PATH} as python relative installation path\")\n # Python extension suffix\n # Try to get from python through sysconfig.get_env_var('EXT_SUFFIX') first,\n # fallback to \".pyd\" if windows and \".so\" for all others.\n pycmd(PY_EXT_SUFFIX \"\n from distutils import sysconfig\n ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')\n print(ext_suffix if ext_suffix else '')\n \")\n if(\"${PY_EXT_SUFFIX}\" STREQUAL \"\")\n if (MSVC)\n set(PY_EXT_SUFFIX \".pyd\")\n else()\n set(PY_EXT_SUFFIX \".so\")\n endif()\n endif()\n\n # ---[ Python.\n add_library(caffe2_pybind11_state MODULE ${Caffe2_CPU_PYTHON_SRCS})\n set_target_properties(caffe2_pybind11_state PROPERTIES COMPILE_FLAGS \"-fvisibility=hidden\")\n set_target_properties(caffe2_pybind11_state PROPERTIES PREFIX \"\")\n set_target_properties(caffe2_pybind11_state PROPERTIES SUFFIX ${PY_EXT_SUFFIX})\n if (APPLE)\n set_target_properties(caffe2_pybind11_state PROPERTIES LINK_FLAGS \"-undefined dynamic_lookup\")\n endif()\n set_target_properties(\n caffe2_pybind11_state PROPERTIES LIBRARY_OUTPUT_DIRECTORY\n ${CMAKE_BINARY_DIR}/caffe2/python)\n target_link_libraries(\n caffe2_pybind11_state caffe2_library)\n install(TARGETS caffe2_pybind11_state DESTINATION \"${PYTHON_LIB_REL_PATH}/caffe2/python\")\n\n if(USE_CUDA)\n add_library(caffe2_pybind11_state_gpu MODULE ${Caffe2_GPU_PYTHON_SRCS})\n set_target_properties(caffe2_pybind11_state_gpu PROPERTIES COMPILE_FLAGS \"-fvisibility=hidden\")\n set_target_properties(caffe2_pybind11_state_gpu PROPERTIES PREFIX \"\")\n set_target_properties(caffe2_pybind11_state_gpu PROPERTIES SUFFIX ${PY_EXT_SUFFIX})\n if (APPLE)\n set_target_properties(caffe2_pybind11_state_gpu PROPERTIES LINK_FLAGS \"-undefined dynamic_lookup\")\n endif()\n set_target_properties(\n caffe2_pybind11_state_gpu PROPERTIES LIBRARY_OUTPUT_DIRECTORY\n ${CMAKE_BINARY_DIR}/caffe2/python)\n target_link_libraries(\n caffe2_pybind11_state_gpu caffe2_library caffe2_gpu_library)\n install(TARGETS caffe2_pybind11_state_gpu DESTINATION \"${PYTHON_LIB_REL_PATH}/caffe2/python\")\n endif()\n\n if (MSVC AND CMAKE_GENERATOR MATCHES \"Visual Studio\")\n # If we are building under windows, we will copy the file from\n # build/caffe2/python/{Debug,Release}/caffe2_pybind11_state.pyd\n # to its parent folder so that we can do in-build execution.\n add_custom_target(windows_python_copy_lib ALL)\n add_dependencies(windows_python_copy_lib caffe2_pybind11_state)\n add_custom_command(\n TARGET windows_python_copy_lib POST_BUILD\n COMMAND ${CMAKE_COMMAND} -E copy\n $\n ${CMAKE_BINARY_DIR}/caffe2/python)\n if (USE_CUDA)\n add_dependencies(windows_python_copy_lib caffe2_pybind11_state_gpu)\n add_custom_command(\n TARGET windows_python_copy_lib POST_BUILD\n COMMAND ${CMAKE_COMMAND} -E copy\n $\n ${CMAKE_BINARY_DIR}/caffe2/python)\n endif()\n endif()\n\n # Finally, Copy all python files to build directory\n # Generate and create all needed __init__.py files, if they aren't already\n # present in the current source tree.\n message(STATUS \"Automatically generating missing __init__.py files.\")\n caffe_autogen_init_py_files()\n\n # Create a custom target that copies all python files.\n file(GLOB_RECURSE PYTHON_SRCS RELATIVE ${PROJECT_SOURCE_DIR}\n \"${PROJECT_SOURCE_DIR}/caffe2/*.py\")\n add_custom_target(python_copy_files ALL)\n if(MSVC OR CMAKE_GENERATOR MATCHES \"Ninja\")\n # ninja fails when the command line is too long so we split\n # the target into several. This would be beneficial for VS also\n # since it build targets in parallel but not custom commands\n foreach(python_src ${PYTHON_SRCS})\n get_filename_component(dir ${python_src} DIRECTORY)\n string(SHA1 name_hash \"${python_src}\")\n # get_filename_component(name_we ${python_src} NAME_WE)\n add_custom_target(python_copy_files_${name_hash}\n COMMAND ${CMAKE_COMMAND} -E copy\n ${PROJECT_SOURCE_DIR}/${python_src} ${CMAKE_BINARY_DIR}/${dir})\n add_dependencies(python_copy_files python_copy_files_${name_hash})\n endforeach()\n else()\n foreach(python_src ${PYTHON_SRCS})\n get_filename_component(dir ${python_src} DIRECTORY)\n add_custom_command(\n TARGET python_copy_files PRE_BUILD\n COMMAND ${CMAKE_COMMAND} -E copy\n ${PROJECT_SOURCE_DIR}/${python_src} ${CMAKE_BINARY_DIR}/${dir})\n endforeach()\n endif()\n\n # Install commands\n # Pick up static python files\n install(DIRECTORY ${CMAKE_BINARY_DIR}/caffe2 DESTINATION ${PYTHON_LIB_REL_PATH}\n FILES_MATCHING PATTERN \"*.py\")\n # Caffe proto files\n install(DIRECTORY ${CMAKE_BINARY_DIR}/caffe DESTINATION ${PYTHON_LIB_REL_PATH}\n FILES_MATCHING PATTERN \"*.py\")\n # Caffe2 proto files\n install(DIRECTORY ${CMAKE_BINARY_DIR}/caffe2 DESTINATION ${PYTHON_LIB_REL_PATH}\n FILES_MATCHING PATTERN \"*.py\")\nendif()\n\n# Finally, set the Caffe2_MAIN_LIBS variable in the parent scope.\nset(Caffe2_MAIN_LIBS ${Caffe2_MAIN_LIBS} PARENT_SCOPE)\n\n\n" }, { "path": "caffe2/__init__.py", "content": "" }, { "path": "caffe2/contrib/CMakeLists.txt", "content": "add_subdirectory(aten)\nadd_subdirectory(gloo)\nadd_subdirectory(nccl)\nadd_subdirectory(prof)\nadd_subdirectory(shm_mutex)\nadd_subdirectory(script)\n# Finally pass the src lists back to the parent\n\n# CPU source, test sources, binary sources\nset(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} PARENT_SCOPE)\nset(Caffe2_CPU_TEST_SRCS ${Caffe2_CPU_TEST_SRCS} PARENT_SCOPE)\nset(Caffe2_CPU_BINARY_SRCS ${Caffe2_CPU_BINARY_SRCS} PARENT_SCOPE)\n\n# GPU source, test sources, binary sources\nset(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} PARENT_SCOPE)\nset(Caffe2_GPU_TEST_SRCS ${Caffe2_GPU_TEST_SRCS} PARENT_SCOPE)\nset(Caffe2_GPU_BINARY_SRCS ${Caffe2_GPU_BINARY_SRCS} PARENT_SCOPE)\n" }, { "path": "caffe2/contrib/__init__.py", "content": "" }, { "path": "caffe2/contrib/aten/CMakeLists.txt", "content": "if(USE_ATEN)\n if(NOT USE_CUDA)\n set(NO_CUDA ON)\n endif()\n set(TORCH_CUDA_ARCH_LIST \"3.5 5.2 6.0 6.1+PTX\")\n set(TORCH_NVCC_FLAGS \"-Xfatbin -compress-all\")\n set(CMAKE_POSITION_INDEPENDENT_CODE ON)\n set(AT_LINK_STYLE STATIC)\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -fvisibility=hidden\")\n set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} -fvisibility=hidden\")\n add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/aten aten EXCLUDE_FROM_ALL)\n\n add_custom_command(OUTPUT aten_op.h\n COMMAND\n python ${CMAKE_CURRENT_SOURCE_DIR}/gen_op.py\n --third_party_root=${PROJECT_SOURCE_DIR}/third_party\n --template_dir=${PROJECT_SOURCE_DIR}/caffe2/contrib/aten\n DEPENDS\n ATen\n ${CMAKE_CURRENT_SOURCE_DIR}/gen_op.py\n ${CMAKE_CURRENT_SOURCE_DIR}/aten_op_template.h)\n\n add_custom_target(__aten_op_header_gen DEPENDS aten_op.h)\n add_library(aten_op_header_gen INTERFACE)\n add_dependencies(aten_op_header_gen __aten_op_header_gen)\n\n set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} \"${CMAKE_CURRENT_SOURCE_DIR}/aten_op.cc\" PARENT_SCOPE)\n set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} \"${CMAKE_CURRENT_SOURCE_DIR}/aten_op_cuda.cc\" PARENT_SCOPE)\nendif()\n" }, { "path": "caffe2/contrib/aten/README.md", "content": "# An ATen operator for Caffe2\n\n[ATen](https://github.com/zdevito/aten) is a simple tensor library thats exposes the Tensor operations in Torch\nand PyTorch directly in C++11. This library provides a generated wrapper around the ATen API\nthat makes these functions available in Caffe2 as an operator. It also makes it accessible using the\nToffeeIR.\n\n\n### Example Usage in Caffe2\n\nFirst identify a function in ATen you want to call in [Functions.h](https://github.com/zdevito/ATen/blob/master/doc/Functions.h),\n[Tensor.h](https://github.com/zdevito/ATen/blob/master/doc/Tensor.h), or [Type.h](https://github.com/zdevito/ATen/blob/master/doc/Type.h).\n\nWe will call the `pow` operator:\n\n```\nstatic inline Tensor pow(const Tensor & self, Scalar exponent);\n```\n\nNow create a Caffe2 operator to call this op. The name of the operator is always `\"ATen\"`,\nand there is always a string attribute `operator` that defines which ATen function to call:\n\n\n```\nimport numpy as np\nfrom caffe2.python import core, workspace\n\n\n# create the Caffe2 Op:\nop = core.CreateOperator(\n \"ATen\",\n [\"MyInput\"],\n [\"MyOutput\"],\n operator=\"pow\", exponent=2.0)\n\n```\n\nEach `Tensor` input becomes an Caffe2 input Blob, and each output becomes a Caffe2 output blob.\nNon-tensor inputs such as `Scalar exponent` become Caffe2 `arg` attributes.\nIn the case of `Scalar` the attributes can be either an integers or floating point numbers.\n\nThe op can now be run like any other Caffe2 operator:\n\n```\nworkspace.FeedBlob(\"MyInput\",np.random.randn(2,3).astype(np.float32))\nworkspace.RunOperatorOnce(op)\nprint(workspace.FetchBlob(\"MyOutput\")\n```\n\nFor methods, the first input is always the `this` Tensor in C++.\nTo call methods of ATen's `Type` objects, you provide an additional string attribute\nthat determines the type:\n\n```\n# create a 2x4 tensor filled with floating point ones\nop = core.CreateOperator(\n \"ATen\",\n [],\n [\"MyOutput\"],\n operator=\"ones\", type=\"Float\", size={2,4})\n```\n\nGenerally ATen operators are polymorphic across input types, and work on both the CPU and CUDA.\n\n### Example Usage via PyTorch Symbolic\n\nThe ATen operator can also be used to define `symbolic` definitions for PyTorch when an operator is being exported\nto ONNX. In this case, the definition of the operator looks the same but is defined using PyTorch's ONNX API:\n\n```\nclass Add(torch.autograd.Function):\n\n @staticmethod\n def symbolic(g, a, b):\n return g.op(\"ATen\", a, b, operator_s = \"add\")\n\n @staticmethod\n def forward(ctx, a, b):\n return a + b\n```\n" }, { "path": "caffe2/contrib/aten/aten_op.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"caffe2/contrib/aten/aten_op.h\"\n#include \"caffe2/utils/math.h\"\n\nnamespace caffe2 {\n\nREGISTER_CPU_OPERATOR(ATen, ATenOp);\ntemplate<>\nat::Backend ATenOp::backend() const {\n return at::kCPU;\n}\n\nOPERATOR_SCHEMA(ATen);\nCAFFE_KNOWN_TYPE(at::Half);\n\nnamespace math {\ntemplate<>\nvoid Set(const size_t N, const at::Half h, at::Half* v, CPUContext * c) {\n Set(0, h.x, (uint16_t*) v, c);\n}\n}\n\n}\n" }, { "path": "caffe2/contrib/aten/aten_op.h", "content": "#include \"caffe2/caffe2/contrib/aten/gen_aten_op.h\"\n" }, { "path": "caffe2/contrib/aten/aten_op_cuda.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"caffe2/contrib/aten/aten_op.h\"\n#include \"caffe2/core/context_gpu.h\"\n\nnamespace caffe2 {\n\nREGISTER_CUDA_OPERATOR(ATen, ATenOp);\ntemplate<>\nat::Backend ATenOp::backend() const {\n return at::kCUDA;\n}\n\nnamespace math {\ntemplate<>\nvoid Set(const size_t N, const at::Half h, at::Half* v, CUDAContext * c) {\n Set(0, h.x, (uint16_t*) v, c);\n}\n}\n\n}\n" }, { "path": "caffe2/contrib/aten/aten_op_template.h", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// a map from descriptor strings (see [DESCRIPTORS])\n// to the key in the switch statement that implements them\nstatic std::unordered_map op_to_key = {\n ${mappings}\n};\n\nnamespace caffe2 {\n\nusing at::Half; // for AT_FORALL_SCALAR_TYPES\n\ntemplate \nclass ATenOp : public Operator {\n public:\n ATenOp(const OperatorDef& operator_def, Workspace* ws)\n : Operator(operator_def, ws) {\n VLOG(2) << \"ATen OpDef: \" << ProtoDebugString(operator_def) << \"\\n\";\n switch(findImplementation(operator_def)) {\n ${implementations}\n default:\n CAFFE_THROW(\"Unexpected key value for aten operator\");\n }\n }\n USE_OPERATOR_CONTEXT_FUNCTIONS;\n\n bool RunOnDevice() override {\n return run_op();\n }\nprivate:\n // actual operator implementation is initialized in ctor.\n std::function run_op;\n at::Backend backend() const;\n\n TypeMeta typeMetaFor(const at::Tensor & t) {\n return typeMetaFor(t.type().scalarType());\n }\n TypeMeta typeMetaFor(at::ScalarType st) {\n #define DEFINE_CASE(ctype,aten_name,_) \\\n case at::k##aten_name: \\\n return TypeMeta::Make();\n switch(st) {\n AT_FORALL_SCALAR_TYPES(DEFINE_CASE)\n default:\n CAFFE_THROW(\"Unknown ATen Type\");\n }\n #undef DEFINE_CASE\n }\n\n at::Type & typeFor(const Tensor & ten) {\n return at::getType(backend(), atScalarTypeFor(ten.meta()));\n }\n at::Tensor tensorWrapping(const Tensor& ten_) {\n auto& ten = const_cast&>(ten_);\n return typeFor(ten).tensorFromBlob(ten.raw_mutable_data(), ten.dims());\n }\n at::Tensor loadInput(size_t i) {\n return tensorWrapping(Input(i));\n }\n std::vector loadInputsAtOffset(size_t s) {\n std::vector results;\n for (size_t i = s; i < InputSize(); i++) {\n results.push_back(loadInput(i));\n }\n return results;\n }\n at::ScalarType atScalarTypeFor(const TypeMeta & meta) {\n #define DEFINE_IF(ctype,aten_name,_) \\\n if(meta.Match()) { \\\n return at::k##aten_name; \\\n }\n AT_FORALL_SCALAR_TYPES(DEFINE_IF)\n #undef DEFINE_IF\n CAFFE_THROW(\"Unknown type meta\"); // TODO: improve error message...\n }\n void assignTo(Tensor * dst, const at::Tensor & src_) {\n at::Tensor src = src_.contiguous();\n auto at_sizes = src.sizes();\n std::vector dims(at_sizes.begin(),at_sizes.end());\n dst->Resize(dims);\n dst->ShareExternalPointer(\n src.data_ptr(), typeMetaFor(src), 0, [src](void* ptr) mutable {\n // return a closure that holds a handle to t until it is called\n // to keep the aten memory alive\n return src.reset();\n });\n }\n void assignListStartingAt(\n size_t offset,\n const std::vector& tensors) {\n for (size_t i = 0; i < tensors.size(); i++) {\n assignTo(Output(offset + i), tensors[i]);\n }\n }\n\n // the AT_FORALL_SCALAR_TYPES macro just gives a 'i' or 'd' argument\n // for each type to specify if it is stored as a integer or a double.\n // We need this workaround here to extract the value in the scalar losslessly\n // because in some cases like 'sum' Torch promotes float to double\n // and will complain if we downcast it with toFloat, causing it\n // to lose precision\n double extract_d(const at::Scalar & s) {\n return s.toDouble();\n }\n int64_t extract_i(const at::Scalar & s) {\n return s.toLong();\n }\n\n void assignTo(Tensor * dst, at::Type & inferred_type, at::Scalar scalar) {\n switch(inferred_type.scalarType()) {\n #define DEFINE_CASE(ctype,aten_name,native) \\\n case at::k##aten_name: { \\\n auto value = extract_##native(scalar); \\\n assignToValue(dst, at::convert(value)); \\\n } break;\n AT_FORALL_SCALAR_TYPES(DEFINE_CASE)\n #undef DEFINE_CASE\n default:\n CAFFE_THROW(\"Unknown ATen Type\");\n }\n }\n template\n void assignToValue(Tensor * dst, T v) {\n dst->Resize(std::vector());\n math::Set(1, v, dst->template mutable_data(), &context_);\n }\n int findImplementation(const OperatorDef& operator_def) {\n CAFFE_ENFORCE(HasArgument(\"operator\"));\n std::string op = OperatorBase::GetSingleArgument(\"operator\", \"\");\n // construct descriptor string ([DESCRIPTORS]) given the attributes\n // and inputs of this operator_def, and look up the implementation key\n // for this variant\n std::stringstream descriptor;\n descriptor << op;\n std::vector attrs;\n for(size_t i = 0; i < operator_def.arg_size(); i++) {\n auto & attr = operator_def.arg(i);\n if(attr.name() == \"operator\" || attr.name() == \"type\" )\n continue;\n attrs.push_back(attr.name());\n }\n std::sort(attrs.begin(), attrs.end());\n for(auto & a : attrs)\n descriptor << \"-\" << a;\n\n std::string descriptor_sized =\n descriptor.str() + \"-\" + caffe2::to_string(InputSize());\n std::string descriptor_var_args = descriptor.str() + \"-*\";\n if (op_to_key.count(descriptor_sized) > 0) {\n return op_to_key[descriptor_sized];\n }\n if (op_to_key.count(descriptor_var_args) > 0) {\n return op_to_key[descriptor_var_args];\n }\n std::stringstream ss;\n ss << \"Attempting to run unknown ATen operator configuration: \"\n << descriptor_sized;\n CAFFE_THROW(ss.str());\n }\n at::Scalar readScalarAttribute(const std::string & name) {\n if(OperatorBase::HasSingleArgumentOfType(name)) {\n return OperatorBase::GetSingleArgument(name, 0);\n } else {\n CAFFE_ENFORCE(OperatorBase::HasSingleArgumentOfType(name));\n return OperatorBase::GetSingleArgument(name, 0);\n }\n }\n template\n T readAttribute(const std::string & name) {\n CAFFE_ENFORCE(OperatorBase::HasSingleArgumentOfType(name));\n return OperatorBase::GetSingleArgument(name, 0);\n }\n std::vector readIntList(const std::string & name) {\n CAFFE_ENFORCE(OperatorBase::HasArgument(name));\n return OperatorBase::GetRepeatedArgument(name, {});\n }\n template \n std::array readBoolMask(const std::string& name) {\n CAFFE_ENFORCE(OperatorBase::HasArgument(name));\n std::vector ints =\n OperatorBase::GetRepeatedArgument(name, {});\n std::array result;\n for (size_t i = 0; i < N; ++i) {\n result[i] = ints.at(i);\n }\n return result;\n }\n at::ScalarType stringToScalarType(const std::string & name) {\n #define DEFINE_IF(type,aten) \\\n if(#type == name) \\\n return at::k##aten;\n DEFINE_IF(float16, Half)\n DEFINE_IF(float, Float)\n DEFINE_IF(double, Double)\n DEFINE_IF(uint8, Byte)\n DEFINE_IF(int8, Char)\n DEFINE_IF(int16, Short)\n DEFINE_IF(int32, Int)\n DEFINE_IF(int64, Long)\n CAFFE_THROW(\"unsupported type annotation: \", name);\n }\n at::Type & stringToType(const std::string & name) {\n return at::getType(backend(), stringToScalarType(name));\n }\n at::Type * readTypeAttribute(const std::string & name) {\n CAFFE_ENFORCE(OperatorBase::HasSingleArgumentOfType(name));\n return &stringToType(OperatorBase::GetSingleArgument(name, \"\"));\n }\n};\n\n}\n" }, { "path": "caffe2/contrib/aten/aten_test.py", "content": "# Copyright (c) 2016-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n##############################################################################\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nfrom caffe2.python import core, dyndep\nfrom hypothesis import given\n\nimport caffe2.python.hypothesis_test_util as hu\nimport hypothesis.strategies as st\nimport numpy as np\n\n\ndyndep.InitOpsLibrary('@/caffe2/caffe2/contrib/aten:aten_op')\n\n\nclass TestATen(hu.HypothesisTestCase):\n\n @given(inputs=hu.tensors(n=2), **hu.gcs)\n def test_add(self, inputs, gc, dc):\n op = core.CreateOperator(\n \"ATen\",\n [\"X\", \"Y\"],\n [\"Z\"],\n operator=\"add\")\n\n def ref(X, Y):\n return [X + Y]\n self.assertReferenceChecks(gc, op, inputs, ref)\n\n @given(inputs=hu.tensors(n=1), **hu.gcs)\n def test_pow(self, inputs, gc, dc):\n op = core.CreateOperator(\n \"ATen\",\n [\"S\"],\n [\"Z\"],\n operator=\"pow\", exponent=2.0)\n\n def ref(X):\n return [np.square(X)]\n\n self.assertReferenceChecks(gc, op, inputs, ref)\n\n @given(x=st.integers(min_value=2, max_value=8), **hu.gcs)\n def test_sort(self, x, gc, dc):\n inputs = [np.random.permutation(x)]\n op = core.CreateOperator(\n \"ATen\",\n [\"S\"],\n [\"Z\", \"I\"],\n operator=\"sort\")\n\n def ref(X):\n return [np.sort(X), np.argsort(X)]\n self.assertReferenceChecks(gc, op, inputs, ref)\n\n @given(inputs=hu.tensors(n=1), **hu.gcs)\n def test_sum(self, inputs, gc, dc):\n op = core.CreateOperator(\n \"ATen\",\n [\"S\"],\n [\"Z\"],\n operator=\"sum\")\n\n def ref(X):\n return [np.sum(X)]\n\n self.assertReferenceChecks(gc, op, inputs, ref)\n\n @given(**hu.gcs)\n def test_ones(self, gc, dc):\n op = core.CreateOperator(\n \"ATen\",\n [],\n [\"Z\"],\n operator=\"ones\", type=\"float\", size={2, 4})\n\n def ref():\n return [np.ones([2, 4])]\n\n self.assertReferenceChecks(gc, op, [], ref)\n\n\nif __name__ == \"__main__\":\n import unittest\n unittest.main()\n" }, { "path": "caffe2/contrib/aten/docs/pytorch_to_caffe2.md", "content": "# Using ONNX and ATen to export models from PyTorch to Caffe2\n\nWhen using ONNX to export a model from PyTorch into Caffe2, you sometimes end up\nhitting operators that are not yet part of the ONNX specification. These may be\noperators that haven't been standardized yet, or custom `torch.autograd.Function` types that\nare specific to a network.\n\nTo bridge this gap, we provide an experimental operator in ONNX that allows you to directly access PyTorch's tensor functions using the ATen library.\n[ATen](https://github.com/zdevito/aten) is the underlying C++ library that PyTorch uses to do tensor operations. Caffe2 has an [ATen operator](https://github.com/caffe2/caffe2/tree/master/caffe2/contrib/aten)\nthat can run these tensor functions in a Caffe2 network after importing them through ONNX.\n\nThis guide explains how to configure Caffe2 and modify your PyTorch program to use\nthis functionality.\n\n### Enable ATen in Caffe2\n\nThe ATen facility in Caffe2 is part of a contrib package and needs to be enabled\nwhen you configure Caffe2 using cmake:\n\n```\ngit clone https://github.com/caffe2/caffe2/\nmkdir caffe2/build\ncd caffe2/build\ncmake -DUSE_ATEN=ON ..\nmake install\n```\n\n### Describe How to Export a PyTorch Autograd Function using ATen\n\nTo export a model to ONNX, PyTorch first creates a trace of all the `torch.autograd.Function`s run\nin the forward pass of a network. For each function in the trace, it calls that function's\n`symbolic` method which describes how to construct the part of the ONNX graph\nthat will compute this function (see [basic_ops.py](https://github.com/pytorch/pytorch/blob/master/torch/autograd/_functions/basic_ops.py#L59) for examples).\n\nWhen equivalent ONNX operators do not exist, you can instead call any ATen function.\nAs an example let's assume we have an autograd function which computes `x*x+y`:\n\n```\n class MyFunction(Function):\n @staticmethod\n def forward(ctx, x, y):\n return x*x + y\n```\n\nWe can add a `symbolic` method to it like so:\n\n```\n class MyFunction(Function):\n @staticmethod\n def forward(ctx, x, y):\n return x*x + y\n @staticmethod\n def symbolic(graph, x, y):\n x2 = graph.at(\"mul\", x, x)\n r = graph.at(\"add\", x2, y)\n # x, y, x2, and r are 'Node' objects\n # print(r) or print(graph) will print out a textual representation for debugging.\n # this representation will be converted to ONNX protobufs on export.\n return r\n```\n\nThe function `graph.at` adds a new ATen op the computation graph.\nYou can call any ATen function using this facility. To do so,\nfirst identify a function in ATen you want to call in [Functions.h](https://github.com/zdevito/ATen/blob/master/doc/Functions.h),\n[Tensor.h](https://github.com/zdevito/ATen/blob/master/doc/Tensor.h), or [Type.h](https://github.com/zdevito/ATen/blob/master/doc/Type.h).\n\nAs an example, we might want to call the `pow` operator:\n\n```\nstatic inline Tensor pow(const Tensor & self, Scalar exponent);\n```\n\nWe can translate this into the equivalent `graph.at` function:\n\n```\n def symbolic(graph, x):\n graph.at(\"pow\", x, exponent_f = 2.0) # compute x**2\n```\n\nTensor arguments to ATen functions become arguments to `graph.at`, while a `Scalar`\nlike `exponent` becomes a keyword argument that specify ONNX attributes.\nAttributes are suffixed with their type (`_f` for floats and `_i` for integers, and `_s` for strings).\n\nFor methods, the first input is always the `this` Tensor in C++.\nTo call methods of ATen's `Type` objects, you provide an additional string attribute\nthat determines the type. For instance, `ones` creates a new constant tensor of all ones:\n```\nclass Type {\n\t...\n\tvirtual Tensor ones(IntList size) const;\n\t...\n};\n```\n\nFrom PyTorch it can be created by adding the type as an additional attribute:\n\n```\n def symbolic(graph, x):\n return graph.at(\"ones\", type_s=\"float\", size_i=[2,4])\n```\n\n\nGenerally ATen operators are polymorphic across input types, and work on both the CPU and CUDA.\n\n## Putting it together\n\nWith these building blocks we can now write and export networks that include custom operators using `torch.onnx.export`:\n\n```\nclass MyModule(nn.Module):\n def forward(self, x, y):\n # you can combine your ATen ops with standard onnx ones\n x = nn.ReLU()(x)\n return MyFunction.apply(x, y)\n\ntorch.onnx.export(MyModule(),\n (Variable(torch.ones(3,4)), Variable(torch.ones(3,4))),\n \"output.onnx\",\n verbose=True)\n```\n\nThis exports the following graph, which contains calls the `ATen` operator:\n\n```\ngraph(%1 : Float(3, 4)\n %2 : Float(3, 4)) {\n %3 : Float(3, 4) = Relu(%1), uses = [%4.i0, %4.i1];\n %4 : UNKNOWN_TYPE = ATen[operator=mul](%3, %3), uses = [%5.i0];\n %5 : Float(3, 4) = ATen[operator=add](%4, %2), uses = [%0.i0];\n return (%5);\n}\n```\n\nThe graph can then be imported using ONNX and run with Caffe2:\n\n```\nimport onnx\nimport caffe2.python.onnx.backend\nimport numpy as np\n\ngraph = onnx.load(\"output.onnx\")\n\na = np.random.randn(3, 2).astype(np.float32)\nb = np.random.randn(3, 2).astype(np.float32)\n\nprepared_backend = caffe2.python.onnx.backend.prepare(graph)\nW = {graph.graph.input[0].name: a, graph.graph.input[1].name: b}\nc2_out = prepared_backend.run(W)[0]\n\nx = np.maximum(a, 0)\nr = x*x + b\nnp.testing.assert_array_almost_equal(r, c2_out)\n```\n\n### Code\n\nFor the full source code for this tutorial, see [sample.py](sample.py).\n" }, { "path": "caffe2/contrib/aten/docs/sample.py", "content": "import numpy as np\n\nfrom torch import nn\nfrom torch.autograd import Variable, Function\nimport torch.onnx\n\nimport onnx\nimport caffe2.python.onnx.backend\n\nclass MyFunction(Function):\n @staticmethod\n def forward(ctx, x, y):\n return x*x + y\n @staticmethod\n def symbolic(graph, x, y):\n x2 = graph.at(\"mul\", x, x)\n r = graph.at(\"add\", x2, y)\n # x, y, x2, and r are 'Node' objects\n # print(r) or print(graph) will print out a textual representation for debugging.\n # this representation will be converted to ONNX protobufs on export.\n return r\n\nclass MyModule(nn.Module):\n def forward(self, x, y):\n # you can combine your ATen ops with standard onnx ones\n x = nn.ReLU()(x)\n return MyFunction.apply(x, y)\n\ntorch.onnx.export(MyModule(),\n (Variable(torch.ones(3,4)), Variable(torch.ones(3,4))),\n \"output.onnx\",\n verbose=True)\n\n# prints the graph for debugging:\n# graph(%1 : Float(3, 4)\n# %2 : Float(3, 4)) {\n# %3 : Float(3, 4) = Relu(%1), uses = [%4.i0, %4.i1];\n# %4 : UNKNOWN_TYPE = ATen[operator=mul](%3, %3), uses = [%5.i0];\n# %5 : Float(3, 4) = ATen[operator=add](%4, %2), uses = [%0.i0];\n# return (%5);\n# }\n\ngraph = onnx.load(\"output.onnx\")\n\na = np.random.randn(3, 4).astype(np.float32)\nb = np.random.randn(3, 4).astype(np.float32)\n\nprepared_backend = caffe2.python.onnx.backend.prepare(graph)\nW = {graph.graph.input[0].name: a, graph.graph.input[1].name: b}\nc2_out = prepared_backend.run(W)[0]\n\nx = np.maximum(a, 0)\nr = x*x + b\nnp.testing.assert_array_almost_equal(r, c2_out)\n" }, { "path": "caffe2/contrib/aten/gen_op.py", "content": "#!/bin/env python\n\n# Copyright (c) 2016-present, Facebook, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n##############################################################################\n\nimport sys\nimport yaml\nimport argparse\nimport os\nfrom copy import deepcopy\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--template_dir\", default=\".\", help=\"where template.h is\")\nparser.add_argument(\"--yaml_dir\", default=\"aten/src/ATen/ATen\",\n help=\"where ATen yaml files are\")\nparser.add_argument(\"--output_prefix\", default=\"\", help=\"\")\nparser.add_argument(\n \"--install_dir\", default=\".\", help=\"where to put generated file\")\nparser.add_argument(\"--third_party_root\", default=\"\", help=\"caffe2 third_party\")\nargs, _ = parser.parse_known_args()\n\nif args.third_party_root:\n sys.path.append(os.path.join(args.third_party_root, \"aten/src/ATen\"))\n from code_template import CodeTemplate as CT\nelse:\n from src.ATen.code_template import CodeTemplate as CT\n\nOP_TEMPLATE = CT.from_file(\n os.path.join(args.template_dir, 'aten_op_template.h'))\n\n\ntry:\n # use faster C loader if available\n from yaml import CLoader as Loader\nexcept ImportError:\n from yaml import Loader\n\n\ndef write(filename, s):\n with open(filename, \"w\") as f:\n f.write(s)\n\n\ndef read(filename):\n with open(filename, \"r\") as f:\n return f.read()\n\n\ndef value_has_tensors(v):\n # Sparse shouldn't appear in public API, seems to be temporary bug\n return \"Tensor\" in v['dynamic_type'] and \"Sparse\" not in v['dynamic_type']\n\n\ndef value_is_tensor_type(v):\n return value_has_tensors(v) and v['dynamic_type'] != 'TensorList'\n\n\n# for each aten type, how do we handle a return value of that type?\nRETURN_MAP = {\n 'Tensor': 'assignTo(Output(${offset}),${output});',\n 'Scalar': 'assignTo(Output(${offset}),*inferred_type, ${output});',\n 'bool': 'assignToValue(Output(${offset}),${output});',\n 'int64_t': 'assignToValue(Output(${offset}),${output});',\n 'std::vector': 'assignListStartingAt(${offset}, ${output});',\n}\n\n# for each non-Tensor aten argument, how to we read it from caffe2's\n# attribute list. Most of these call runtime functions defined in the\n# template class.\nARGUMENT_MAP = {\n 'Scalar': 'at::Scalar ${arg} = readScalarAttribute(\"${arg}\");',\n 'bool': 'bool ${arg} = readAttribute(\"${arg}\");',\n 'int': 'int ${arg} = readAttribute(\"${arg}\");',\n 'double': 'double ${arg} = readAttribute(\"${arg}\");',\n 'int64_t': 'int64_t ${arg} = readAttribute(\"${arg}\");',\n 'IntList': 'auto ${arg} = readIntList(\"${arg}\");',\n 'std::array': 'auto ${arg} = readBoolMask<2>(\"${arg}\");',\n 'std::array': 'auto ${arg} = readBoolMask<3>(\"${arg}\");',\n}\n\n\ndef expand(o):\n num_defaults = sum(1 if 'default' in arg else 0 for arg in o['arguments'])\n results = [o]\n for i in range(0, num_defaults):\n # last num_default values should be default\n assert('default' in o['arguments'][-(i + 1)])\n v = deepcopy(o)\n v['arguments'] = v['arguments'][:-(i + 1)]\n results.append(v)\n return results\n\n\n# filter the list of declarations removing things we cannot support\ndef supports(o):\n # skip all in-place operators for now since aten cannot Resize\n # caffe2 memory inside an operator\n if o['inplace']:\n return False\n\n # _out variants also work in-place on arguments taken as destinations\n # we also cannot handle these because aten cannot resize caffe2 Tensors\n if \"_out\" in o['name']:\n return False\n\n # skip return types we cannot handle\n for ret in o['returns']:\n if not value_has_tensors(ret) and ret['type'] not in RETURN_MAP:\n print(\"Skipping {} Because of Ret: {} ({})\".format(\n o['name'], ret['type'], ret['dynamic_type']))\n return False\n\n # skip arguments we cannot handle\n for arg in o['arguments']:\n if not value_has_tensors(arg) and arg['type'] not in ARGUMENT_MAP:\n print(\"Skipping {} Because of Arg: {} ({}) \".format(\n o['name'], arg['type'], arg['dynamic_type']))\n return False\n return True\n\n\n# template for each potential operator.\n# each operator has an integer 'key' associated with it, and\n# a lambda that defines the operator\n# non-tensor attributes are created in ${initialization}\n# and then saved as arguments to the lambda\n# Inputs/Outputs are read inside the lambda\nOPTION_TEMPLATE = CT(\"\"\"\\\ncase ${key}: { // ${name}\n ${initialization}\n run_op = [=] {\n ${statements}\n auto the_result = ${invocation};\n ${assignments}\n return true;\n };\n} break;\n\"\"\")\n\n\ndef get_output(o, i):\n if len(o['returns']) == 1:\n return 'the_result'\n else:\n return 'std::get<{}>(the_result)'.format(i)\n\n\ndef attribute_names(o):\n return sorted([a['name'] for a in o['arguments'] if not value_has_tensors(a)])\n\n\ndef required_attribute_names(o):\n return sorted([a['name'] for a in o['arguments'] if not value_has_tensors(a) and 'default' not in a])\n\n\ndef self_as_first_argument(arguments):\n return ([a for a in arguments if a['name'] == 'self'] +\n [a for a in arguments if a['name'] != 'self'])\n\n\ndef get_num_inputs(o):\n args = 0\n for a in o['arguments']:\n if a['type'] == 'TensorList':\n return '*'\n elif value_has_tensors(a):\n args += 1\n return str(args)\n\n\nif __name__ == '__main__':\n decls = yaml.load(read(os.path.join(args.yaml_dir, 'Declarations.yaml')), Loader=Loader)\n filtered = [expanded for o in decls for expanded in expand(o) if supports(expanded)]\n top_env = {\n 'mappings': [],\n 'implementations': [],\n }\n seen = set()\n key = 0\n for o in filtered:\n # [DESCRIPTORS]\n # each option is associated with a descriptor string that is used\n # to figure out which version of an op is being used:\n # The format is:\n # opname-num_inputs-attribute_1-attribute2\n # Example:\n # lerp-2-weight\n # the operator lerp takes 2 arguments and has the attribute weight\n attr_names = attribute_names(o)\n num_inputs = get_num_inputs(o)\n descriptor = '-'.join([o['name']] + attr_names + [num_inputs])\n if descriptor in seen:\n continue\n seen.add(descriptor)\n\n # map from descriptor string to the integer key in the switch statements\n # that initializes the operators\n top_env['mappings'].append('{{ \"{}\", {} }},'.format(descriptor, key))\n env = {\n 'name': o['name'],\n 'statements': [],\n 'arguments': [],\n 'assignments': [],\n 'initialization': [],\n 'key': str(key),\n }\n defined_inferred_type = False\n\n if 'Tensor' in o['method_of']:\n # make sure 'self' is the first argument. currently Declarations.yaml\n # does not always do this. Instead it keeps the argument list the same order\n # as the Type method.\n o['arguments'] = self_as_first_argument(o['arguments'])\n elif 'namespace' not in o['method_of']:\n # methods on type like 'ones' or 'zeros' always take a\n # string attribute that is translated into the at::Type object\n # e.g. \"Float\" is at::kFloat\n assert('Type' in o['method_of'])\n defined_inferred_type = True\n env['initialization'].append(\n 'auto inferred_type = readTypeAttribute(\"type\");')\n\n i = 0\n for arg in o['arguments']:\n env['arguments'].append(arg['name'])\n if arg['type'] == 'TensorList':\n env['statements'].append(\n 'auto {} = loadInputsAtOffset({});'.format(arg['name'], i))\n elif value_is_tensor_type(arg):\n assert(i != '*') # tensor list is not last argument\n # load tensor inputs from Caffe2\n env['statements'].append(\n \"auto {} = loadInput({});\".format(arg['name'], i))\n i += 1\n if arg['dynamic_type'] == 'Tensor' and not defined_inferred_type:\n # first tensor input is used to define the output type.\n defined_inferred_type = True\n env['statements'].append(\n 'auto inferred_type = &({}.type());'.format(\n arg['name']))\n else:\n init = CT(ARGUMENT_MAP[arg['type']]).substitute(env, arg=arg['name'])\n env['initialization'].append(init)\n\n for i, r in enumerate(o['returns']):\n t = RETURN_MAP[r['type'] if not value_is_tensor_type(r) else 'Tensor']\n assignment = CT(t).substitute(env, offset=i, output=get_output(o, i))\n env['assignments'].append(assignment)\n\n if 'Tensor' in o['method_of']:\n env['invocation'] = \"self.{}({})\".format(\n o['name'], ', '.join(env['arguments'][1:]))\n elif 'namespace' in o['method_of']:\n env['invocation'] = CT(\"at::${name}(${arguments})\").substitute(env)\n else:\n assert('Type' in o['method_of'])\n env['invocation'] = CT(\n 'inferred_type->${name}(${arguments})').substitute(env)\n\n top_env['implementations'].append(OPTION_TEMPLATE.substitute(env))\n key += 1\n write(os.path.join(args.install_dir, args.output_prefix + \"aten_op.h\"), OP_TEMPLATE.substitute(top_env))\n" }, { "path": "caffe2/contrib/cuda-convnet2/LICENSE", "content": "\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n" }, { "path": "caffe2/contrib/cuda-convnet2/README.md", "content": "# cuda-convnet2\nAutomatically exported from code.google.com/p/cuda-convnet2\n\nYou can read the documentation in two ways:\n\n1. On this site: go to branches > wiki.\n2. On Google Code (for now?): https://code.google.com/p/cuda-convnet2/\n" }, { "path": "caffe2/contrib/cuda-convnet2/build.sh", "content": "#!/bin/sh\n# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n###############################################################################\n\n# Fill in the below environment variables.\n#\n# If you're not sure what these paths should be, \n# you can use the find command to try to locate them.\n# For example, NUMPY_INCLUDE_PATH contains the file\n# arrayobject.h. So you can search for it like this:\n# \n# find /usr -name arrayobject.h\n# \n# (it'll almost certainly be under /usr)\n\n# CUDA toolkit installation directory.\nexport CUDA_INSTALL_PATH=/usr/local/cuda\n\n# Python include directory. This should contain the file Python.h, among others.\nexport PYTHON_INCLUDE_PATH=/usr/include/python2.7\n\n# Numpy include directory. This should contain the file arrayobject.h, among others.\nexport NUMPY_INCLUDE_PATH=/usr/lib/python2.7/dist-packages/numpy/core/include/numpy/\n\n# ATLAS library directory. This should contain the file libcblas.so, among others.\nexport ATLAS_LIB_PATH=/usr/lib/atlas-base\n\n# You don't have to change these:\nexport LD_LIBRARY_PATH=$CUDA_INSTALL_PATH/lib64:$LD_LIBRARY_PATH\nexport CUDA_SDK_PATH=$CUDA_INSTALL_PATH/samples\nexport PATH=$PATH:$CUDA_INSTALL_PATH/bin\n\ncd util && make numpy=1 -j $* && cd ..\ncd nvmatrix && make -j $* && cd ..\ncd cudaconv3 && make -j $* && cd ..\ncd cudaconvnet && make -j $* && cd ..\ncd make-data/pyext && make -j $* && cd ../..\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/convdata.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom python_util.data import *\nimport numpy.random as nr\nimport numpy as n\nimport random as r\nfrom time import time\nfrom threading import Thread\nfrom math import sqrt\nimport sys\n#from matplotlib import pylab as pl\nfrom PIL import Image\nfrom StringIO import StringIO\nfrom time import time\nimport itertools as it\n \nclass JPEGBatchLoaderThread(Thread):\n def __init__(self, dp, batch_num, label_offset, list_out):\n Thread.__init__(self)\n self.list_out = list_out\n self.label_offset = label_offset\n self.dp = dp\n self.batch_num = batch_num\n \n @staticmethod\n def load_jpeg_batch(rawdics, dp, label_offset):\n if type(rawdics) != list:\n rawdics = [rawdics]\n nc_total = sum(len(r['data']) for r in rawdics)\n\n jpeg_strs = list(it.chain.from_iterable(rd['data'] for rd in rawdics))\n labels = list(it.chain.from_iterable(rd['labels'] for rd in rawdics))\n \n img_mat = n.empty((nc_total * dp.data_mult, dp.inner_pixels * dp.num_colors), dtype=n.float32)\n lab_mat = n.zeros((nc_total, dp.get_num_classes()), dtype=n.float32)\n dp.convnet.libmodel.decodeJpeg(jpeg_strs, img_mat, dp.img_size, dp.inner_size, dp.test, dp.multiview)\n lab_vec = n.tile(n.asarray([(l[nr.randint(len(l))] if len(l) > 0 else -1) + label_offset for l in labels], dtype=n.single).reshape((nc_total, 1)), (dp.data_mult,1))\n for c in xrange(nc_total):\n lab_mat[c, [z + label_offset for z in labels[c]]] = 1\n lab_mat = n.tile(lab_mat, (dp.data_mult, 1))\n \n\n return {'data': img_mat[:nc_total * dp.data_mult,:],\n 'labvec': lab_vec[:nc_total * dp.data_mult,:],\n 'labmat': lab_mat[:nc_total * dp.data_mult,:]}\n \n def run(self):\n rawdics = self.dp.get_batch(self.batch_num)\n p = JPEGBatchLoaderThread.load_jpeg_batch(rawdics,\n self.dp,\n self.label_offset)\n self.list_out.append(p)\n \nclass ColorNoiseMakerThread(Thread):\n def __init__(self, pca_stdevs, pca_vecs, num_noise, list_out):\n Thread.__init__(self)\n self.pca_stdevs, self.pca_vecs = pca_stdevs, pca_vecs\n self.num_noise = num_noise\n self.list_out = list_out\n \n def run(self):\n noise = n.dot(nr.randn(self.num_noise, 3).astype(n.single) * self.pca_stdevs.T, self.pca_vecs.T)\n self.list_out.append(noise)\n\nclass ImageDataProvider(LabeledDataProvider):\n def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batchnum=None, dp_params=None, test=False):\n LabeledDataProvider.__init__(self, data_dir, batch_range, init_epoch, init_batchnum, dp_params, test)\n self.data_mean = self.batch_meta['data_mean'].astype(n.single)\n self.color_eig = self.batch_meta['color_pca'][1].astype(n.single)\n self.color_stdevs = n.c_[self.batch_meta['color_pca'][0].astype(n.single)]\n self.color_noise_coeff = dp_params['color_noise']\n self.num_colors = 3\n self.img_size = int(sqrt(self.batch_meta['num_vis'] / self.num_colors))\n self.mini = dp_params['minibatch_size']\n self.inner_size = dp_params['inner_size'] if dp_params['inner_size'] > 0 else self.img_size\n self.inner_pixels = self.inner_size **2\n self.border_size = (self.img_size - self.inner_size) / 2\n self.multiview = dp_params['multiview_test'] and test\n self.num_views = 5*2\n self.data_mult = self.num_views if self.multiview else 1\n self.batch_size = self.batch_meta['batch_size']\n self.label_offset = 0 if 'label_offset' not in self.batch_meta else self.batch_meta['label_offset']\n self.scalar_mean = dp_params['scalar_mean'] \n # Maintain pointers to previously-returned data matrices so they don't get garbage collected.\n self.data = [None, None] # These are pointers to previously-returned data matrices\n\n self.loader_thread, self.color_noise_thread = None, None\n self.convnet = dp_params['convnet']\n \n self.num_noise = self.batch_size\n self.batches_generated, self.loaders_started = 0, 0\n self.data_mean_crop = self.data_mean.reshape((self.num_colors,self.img_size,self.img_size))[:,self.border_size:self.border_size+self.inner_size,self.border_size:self.border_size+self.inner_size].reshape((1,3*self.inner_size**2))\n\n if self.scalar_mean >= 0:\n self.data_mean_crop = self.scalar_mean\n \n def showimg(self, img):\n from matplotlib import pylab as pl\n pixels = img.shape[0] / 3\n size = int(sqrt(pixels))\n img = img.reshape((3,size,size)).swapaxes(0,2).swapaxes(0,1)\n pl.imshow(img, interpolation='nearest')\n pl.show()\n \n def get_data_dims(self, idx=0):\n if idx == 0:\n return self.inner_size**2 * 3\n if idx == 2:\n return self.get_num_classes()\n return 1\n\n def start_loader(self, batch_idx):\n self.load_data = []\n self.loader_thread = JPEGBatchLoaderThread(self,\n self.batch_range[batch_idx],\n self.label_offset,\n self.load_data)\n self.loader_thread.start()\n \n def start_color_noise_maker(self):\n color_noise_list = []\n self.color_noise_thread = ColorNoiseMakerThread(self.color_stdevs, self.color_eig, self.num_noise, color_noise_list)\n self.color_noise_thread.start()\n return color_noise_list\n\n def set_labels(self, datadic):\n pass\n \n def get_data_from_loader(self):\n if self.loader_thread is None:\n self.start_loader(self.batch_idx)\n self.loader_thread.join()\n self.data[self.d_idx] = self.load_data[0]\n\n self.start_loader(self.get_next_batch_idx())\n else:\n # Set the argument to join to 0 to re-enable batch reuse\n self.loader_thread.join()\n if not self.loader_thread.is_alive():\n self.data[self.d_idx] = self.load_data[0]\n self.start_loader(self.get_next_batch_idx())\n #else:\n # print \"Re-using batch\"\n self.advance_batch()\n \n def add_color_noise(self):\n # At this point the data already has 0 mean.\n # So I'm going to add noise to it, but I'm also going to scale down\n # the original data. This is so that the overall scale of the training\n # data doesn't become too different from the test data.\n\n s = self.data[self.d_idx]['data'].shape\n cropped_size = self.get_data_dims(0) / 3\n ncases = s[0]\n\n if self.color_noise_thread is None:\n self.color_noise_list = self.start_color_noise_maker()\n self.color_noise_thread.join()\n self.color_noise = self.color_noise_list[0]\n self.color_noise_list = self.start_color_noise_maker()\n else:\n self.color_noise_thread.join(0)\n if not self.color_noise_thread.is_alive():\n self.color_noise = self.color_noise_list[0]\n self.color_noise_list = self.start_color_noise_maker()\n\n self.data[self.d_idx]['data'] = self.data[self.d_idx]['data'].reshape((ncases*3, cropped_size))\n self.color_noise = self.color_noise[:ncases,:].reshape((3*ncases, 1))\n self.data[self.d_idx]['data'] += self.color_noise * self.color_noise_coeff\n self.data[self.d_idx]['data'] = self.data[self.d_idx]['data'].reshape((ncases, 3* cropped_size))\n self.data[self.d_idx]['data'] *= 1.0 / (1.0 + self.color_noise_coeff) # <--- NOTE: This is the slow line, 0.25sec. Down from 0.75sec when I used division.\n \n def get_next_batch(self):\n self.d_idx = self.batches_generated % 2\n epoch, batchnum = self.curr_epoch, self.curr_batchnum\n\n self.get_data_from_loader()\n\n # Subtract mean\n self.data[self.d_idx]['data'] -= self.data_mean_crop\n \n if self.color_noise_coeff > 0 and not self.test:\n self.add_color_noise()\n self.batches_generated += 1\n \n return epoch, batchnum, [self.data[self.d_idx]['data'].T, self.data[self.d_idx]['labvec'].T, self.data[self.d_idx]['labmat'].T]\n \n \n # Takes as input an array returned by get_next_batch\n # Returns a (numCases, imgSize, imgSize, 3) array which can be\n # fed to pylab for plotting.\n # This is used by shownet.py to plot test case predictions.\n def get_plottable_data(self, data, add_mean=True):\n mean = self.data_mean_crop.reshape((data.shape[0],1)) if data.flags.f_contiguous or self.scalar_mean else self.data_mean_crop.reshape((data.shape[0],1))\n return n.require((data + (mean if add_mean else 0)).T.reshape(data.shape[1], 3, self.inner_size, self.inner_size).swapaxes(1,3).swapaxes(1,2) / 255.0, dtype=n.single)\n \nclass CIFARDataProvider(LabeledDataProvider):\n def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batchnum=None, dp_params=None, test=False):\n LabeledDataProvider.__init__(self, data_dir, batch_range, init_epoch, init_batchnum, dp_params, test)\n self.img_size = 32 \n self.num_colors = 3\n self.inner_size = dp_params['inner_size'] if dp_params['inner_size'] > 0 else self.batch_meta['img_size']\n self.border_size = (self.img_size - self.inner_size) / 2\n self.multiview = dp_params['multiview_test'] and test\n self.num_views = 9\n self.scalar_mean = dp_params['scalar_mean'] \n self.data_mult = self.num_views if self.multiview else 1\n self.data_dic = []\n for i in batch_range:\n self.data_dic += [unpickle(self.get_data_file_name(i))]\n self.data_dic[-1][\"labels\"] = n.require(self.data_dic[-1]['labels'], dtype=n.single)\n self.data_dic[-1][\"labels\"] = n.require(n.tile(self.data_dic[-1][\"labels\"].reshape((1, n.prod(self.data_dic[-1][\"labels\"].shape))), (1, self.data_mult)), requirements='C')\n self.data_dic[-1]['data'] = n.require(self.data_dic[-1]['data'] - self.scalar_mean, dtype=n.single, requirements='C')\n \n self.cropped_data = [n.zeros((self.get_data_dims(), self.data_dic[0]['data'].shape[1]*self.data_mult), dtype=n.single) for x in xrange(2)]\n\n self.batches_generated = 0\n self.data_mean = self.batch_meta['data_mean'].reshape((self.num_colors,self.img_size,self.img_size))[:,self.border_size:self.border_size+self.inner_size,self.border_size:self.border_size+self.inner_size].reshape((self.get_data_dims(), 1))\n\n def get_next_batch(self):\n epoch, batchnum = self.curr_epoch, self.curr_batchnum\n self.advance_batch()\n bidx = batchnum - self.batch_range[0]\n\n cropped = self.cropped_data[self.batches_generated % 2]\n\n self.__trim_borders(self.data_dic[bidx]['data'], cropped)\n cropped -= self.data_mean\n self.batches_generated += 1\n return epoch, batchnum, [cropped, self.data_dic[bidx]['labels']]\n \n def get_data_dims(self, idx=0):\n return self.inner_size**2 * self.num_colors if idx == 0 else 1\n\n # Takes as input an array returned by get_next_batch\n # Returns a (numCases, imgSize, imgSize, 3) array which can be\n # fed to pylab for plotting.\n # This is used by shownet.py to plot test case predictions.\n def get_plottable_data(self, data):\n return n.require((data + self.data_mean).T.reshape(data.shape[1], 3, self.inner_size, self.inner_size).swapaxes(1,3).swapaxes(1,2) / 255.0, dtype=n.single)\n \n def __trim_borders(self, x, target):\n y = x.reshape(self.num_colors, self.img_size, self.img_size, x.shape[1])\n\n if self.test: # don't need to loop over cases\n if self.multiview:\n start_positions = [(0,0), (0, self.border_size), (0, self.border_size*2),\n (self.border_size, 0), (self.border_size, self.border_size), (self.border_size, self.border_size*2),\n (self.border_size*2, 0), (self.border_size*2, self.border_size), (self.border_size*2, self.border_size*2)]\n end_positions = [(sy+self.inner_size, sx+self.inner_size) for (sy,sx) in start_positions]\n for i in xrange(self.num_views):\n target[:,i * x.shape[1]:(i+1)* x.shape[1]] = y[:,start_positions[i][0]:end_positions[i][0],start_positions[i][1]:end_positions[i][1],:].reshape((self.get_data_dims(),x.shape[1]))\n else:\n pic = y[:,self.border_size:self.border_size+self.inner_size,self.border_size:self.border_size+self.inner_size, :] # just take the center for now\n target[:,:] = pic.reshape((self.get_data_dims(), x.shape[1]))\n else:\n for c in xrange(x.shape[1]): # loop over cases\n startY, startX = nr.randint(0,self.border_size*2 + 1), nr.randint(0,self.border_size*2 + 1)\n endY, endX = startY + self.inner_size, startX + self.inner_size\n pic = y[:,startY:endY,startX:endX, c]\n if nr.randint(2) == 0: # also flip the image with 50% probability\n pic = pic[:,:,::-1]\n target[:,c] = pic.reshape((self.get_data_dims(),))\n\nclass DummyConvNetLogRegDataProvider(LabeledDummyDataProvider):\n def __init__(self, data_dim):\n LabeledDummyDataProvider.__init__(self, data_dim)\n\n self.img_size = int(sqrt(data_dim/3))\n \n def get_next_batch(self):\n epoch, batchnum, dic = LabeledDummyDataProvider.get_next_batch(self)\n dic = {'data': dic[0], 'labels': dic[1]}\n print dic['data'].shape, dic['labels'].shape\n return epoch, batchnum, [dic['data'], dic['labels']]\n \n # Returns the dimensionality of the two data matrices returned by get_next_batch\n def get_data_dims(self, idx=0):\n return self.batch_meta['num_vis'] if idx == 0 else 1\n" }, { "path": "caffe2/contrib/cuda-convnet2/convnet.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport numpy as n\nimport numpy.random as nr\nimport random as r\nfrom python_util.util import *\nfrom python_util.data import *\nfrom python_util.options import *\nfrom python_util.gpumodel import *\nimport sys\nimport math as m\nimport layer as lay\nfrom convdata import ImageDataProvider, CIFARDataProvider, DummyConvNetLogRegDataProvider\nfrom os import linesep as NL\nimport copy as cp\nimport os\n\nclass Driver(object):\n def __init__(self, convnet):\n self.convnet = convnet\n \n def on_start_batch(self, batch_data, train):\n pass\n \n def on_finish_batch(self):\n pass\n\nclass GradCheckDriver(Driver):\n def on_start_batch(self, batch_data, train):\n data = batch_data[2]\n self.convnet.libmodel.checkGradients(data)\n\nclass TrainingDriver(Driver):\n def on_start_batch(self, batch_data, train):\n data = batch_data[2]\n self.convnet.libmodel.startBatch(data, self.convnet.get_progress(), not train)\n\nclass MultiviewTestDriver(TrainingDriver):\n def on_start_batch(self, batch_data, train):\n self.write_output = False\n if train:\n TrainingDriver.on_start_batch(self, batch_data, train)\n else:\n data = batch_data[2]\n num_views = self.convnet.test_data_provider.num_views\n if self.convnet.test_out != \"\" and self.convnet.logreg_name != \"\":\n self.write_output = True\n self.test_file_name = os.path.join(self.convnet.test_out, 'test_preds_%d' % batch_data[1])\n self.probs = n.zeros((data[0].shape[1]/num_views, self.convnet.test_data_provider.get_num_classes()), dtype=n.single)\n self.convnet.libmodel.startMultiviewTest(data, num_views, self.probs, self.convnet.logreg_name)\n else:\n self.convnet.libmodel.startMultiviewTest(data, num_views)\n \n def on_finish_batch(self):\n if self.write_output:\n if not os.path.exists(self.convnet.test_out):\n os.makedirs(self.convnet.test_out)\n pickle(self.test_file_name, {'data': self.probs,\n 'note': 'generated from %s' % self.convnet.save_file})\n\nclass FeatureWriterDriver(Driver):\n def __init__(self, convnet):\n Driver.__init__(self, convnet)\n self.last_batch = convnet.test_batch_range[-1]\n \n def on_start_batch(self, batch_data, train):\n if train:\n raise ModelStateException(\"FeatureWriter must be used in conjunction with --test-only=1. It writes test data features.\")\n \n self.batchnum, self.data = batch_data[1], batch_data[2]\n \n if not os.path.exists(self.convnet.feature_path):\n os.makedirs(self.convnet.feature_path)\n \n self.num_ftrs = self.convnet.layers[self.convnet.write_features]['outputs']\n self.ftrs = n.zeros((self.data[0].shape[1], self.num_ftrs), dtype=n.single)\n self.convnet.libmodel.startFeatureWriter(self.data, [self.ftrs], [self.convnet.write_features])\n \n def on_finish_batch(self):\n path_out = os.path.join(self.convnet.feature_path, 'data_batch_%d' % self.batchnum)\n pickle(path_out, {'data': self.ftrs, 'labels': self.data[1]})\n print \"Wrote feature file %s\" % path_out\n if self.batchnum == self.last_batch:\n pickle(os.path.join(self.convnet.feature_path, 'batches.meta'), {'source_model':self.convnet.load_file,\n 'num_vis':self.num_ftrs,\n 'batch_size': self.convnet.test_data_provider.batch_meta['batch_size']})\n\nclass ConvNet(IGPUModel):\n def __init__(self, op, load_dic, dp_params={}):\n filename_options = []\n for v in ('color_noise', 'multiview_test', 'inner_size', 'scalar_mean', 'minibatch_size'):\n dp_params[v] = op.get_value(v)\n\n IGPUModel.__init__(self, \"ConvNet\", op, load_dic, filename_options, dp_params=dp_params)\n \n def import_model(self):\n lib_name = \"cudaconvnet._ConvNet\"\n print \"=========================\"\n print \"Importing %s C++ module\" % lib_name\n self.libmodel = __import__(lib_name,fromlist=['_ConvNet'])\n \n def init_model_lib(self):\n self.libmodel.initModel(self.layers,\n self.device_ids,\n self.minibatch_size,\n self.conserve_mem)\n \n def init_model_state(self):\n ms = self.model_state\n layers = ms['layers'] if self.loaded_from_checkpoint else {}\n ms['layers'] = lay.LayerParser.parse_layers(os.path.join(self.layer_path, self.layer_def),\n os.path.join(self.layer_path, self.layer_params), self, layers=layers)\n \n self.do_decouple_conv()\n self.do_unshare_weights()\n\n self.op.set_value('conv_to_local', [], parse=False)\n self.op.set_value('unshare_weights', [], parse=False)\n \n self.set_driver()\n \n def do_decouple_conv(self):\n # Convert convolutional layers to local\n if len(self.op.get_value('conv_to_local')) > 0:\n for lname in self.op.get_value('conv_to_local'):\n if self.model_state['layers'][lname]['type'] == 'conv':\n lay.LocalLayerParser.conv_to_local(self.model_state['layers'], lname)\n \n def do_unshare_weights(self):\n # Decouple weight matrices\n if len(self.op.get_value('unshare_weights')) > 0:\n for name_str in self.op.get_value('unshare_weights'):\n if name_str:\n name = lay.WeightLayerParser.get_layer_name(name_str)\n if name is not None:\n name, idx = name[0], name[1]\n if name not in self.model_state['layers']:\n raise ModelStateException(\"Layer '%s' does not exist; unable to unshare\" % name)\n layer = self.model_state['layers'][name]\n lay.WeightLayerParser.unshare_weights(layer, self.model_state['layers'], matrix_idx=idx)\n else:\n raise ModelStateException(\"Invalid layer name '%s'; unable to unshare.\" % name_str)\n \n def set_driver(self):\n if self.op.get_value('check_grads'):\n self.driver = GradCheckDriver(self)\n elif self.op.get_value('multiview_test'):\n self.driver = MultiviewTestDriver(self)\n elif self.op.get_value('write_features'):\n self.driver = FeatureWriterDriver(self)\n else:\n self.driver = TrainingDriver(self)\n\n def fill_excused_options(self):\n if self.op.get_value('check_grads'):\n self.op.set_value('save_path', '')\n self.op.set_value('train_batch_range', '0')\n self.op.set_value('test_batch_range', '0')\n self.op.set_value('data_path', '')\n \n # Make sure the data provider returned data in proper format\n def parse_batch_data(self, batch_data, train=True):\n if max(d.dtype != n.single for d in batch_data[2]):\n raise DataProviderException(\"All matrices returned by data provider must consist of single-precision floats.\")\n return batch_data\n\n def start_batch(self, batch_data, train=True):\n self.driver.on_start_batch(batch_data, train)\n \n def finish_batch(self):\n ret = IGPUModel.finish_batch(self)\n self.driver.on_finish_batch()\n return ret\n \n def print_iteration(self):\n print \"%d.%d (%.2f%%)...\" % (self.epoch, self.batchnum, 100 * self.get_progress()),\n \n def print_train_time(self, compute_time_py):\n print \"(%.3f sec)\" % (compute_time_py)\n \n def print_costs(self, cost_outputs):\n costs, num_cases = cost_outputs[0], cost_outputs[1]\n children = set()\n for errname in costs:\n if sum(errname in self.layers[z]['children'] for z in costs) == 0:\n# print self.layers[errname]['children']\n for child in set(self.layers[errname]['children']) & set(costs.keys()):\n costs[errname] = [v + u for v, u in zip(costs[errname], costs[child])]\n children.add(child)\n \n filtered_costs = eval(self.layers[errname]['outputFilter'])(costs[errname], num_cases)\n print \"%s: \" % errname,\n if 'outputFilterFormatter' not in self.layers[errname]:\n print \", \".join(\"%.6f\" % v for v in filtered_costs),\n else:\n print eval(self.layers[errname]['outputFilterFormatter'])(self,filtered_costs),\n if m.isnan(filtered_costs[0]) or m.isinf(filtered_costs[0]):\n print \"<- error nan or inf!\"\n sys.exit(1)\n for c in children:\n del costs[c]\n \n def print_train_results(self):\n self.print_costs(self.train_outputs[-1])\n \n def print_test_status(self):\n pass\n \n def print_test_results(self):\n print NL + \"======================Test output======================\"\n self.print_costs(self.test_outputs[-1])\n if not self.test_only:\n print NL + \"----------------------Averages-------------------------\"\n self.print_costs(self.aggregate_test_outputs(self.test_outputs[-len(self.test_batch_range):]))\n print NL + \"-------------------------------------------------------\",\n for name,val in sorted(self.layers.items(), key=lambda x: x[1]['id']): # This is kind of hacky but will do for now.\n l = self.layers[name]\n if 'weights' in l:\n wscales = [(l['name'], i, n.mean(n.abs(w)), n.mean(n.abs(wi))) for i,(w,wi) in enumerate(zip(l['weights'],l['weightsInc']))]\n print \"\"\n print NL.join(\"Layer '%s' weights[%d]: %e [%e] [%e]\" % (s[0], s[1], s[2], s[3], s[3]/s[2] if s[2] > 0 else 0) for s in wscales),\n print \"%sLayer '%s' biases: %e [%e]\" % (NL, l['name'], n.mean(n.abs(l['biases'])), n.mean(n.abs(l['biasesInc']))),\n print \"\"\n \n def conditional_save(self):\n self.save_state()\n \n def aggregate_test_outputs(self, test_outputs):\n test_outputs = cp.deepcopy(test_outputs)\n num_cases = sum(t[1] for t in test_outputs)\n for i in xrange(1 ,len(test_outputs)):\n for k,v in test_outputs[i][0].items():\n for j in xrange(len(v)):\n test_outputs[0][0][k][j] += test_outputs[i][0][k][j]\n \n return (test_outputs[0][0], num_cases)\n \n @classmethod\n def get_options_parser(cls):\n op = IGPUModel.get_options_parser()\n op.add_option(\"mini\", \"minibatch_size\", IntegerOptionParser, \"Minibatch size\", default=128)\n op.add_option(\"layer-def\", \"layer_def\", StringOptionParser, \"Layer definition file\", set_once=False)\n op.add_option(\"layer-params\", \"layer_params\", StringOptionParser, \"Layer parameter file\")\n op.add_option(\"layer-path\", \"layer_path\", StringOptionParser, \"Layer file path prefix\", default=\"\")\n op.add_option(\"check-grads\", \"check_grads\", BooleanOptionParser, \"Check gradients and quit?\", default=0, excuses=['data_path','save_path', 'save_file_override', 'train_batch_range','test_batch_range'])\n op.add_option(\"multiview-test\", \"multiview_test\", BooleanOptionParser, \"Cropped DP: test on multiple patches?\", default=0)\n op.add_option(\"inner-size\", \"inner_size\", IntegerOptionParser, \"Cropped DP: crop size (0 = don't crop)\", default=0, set_once=True)\n op.add_option(\"conv-to-local\", \"conv_to_local\", ListOptionParser(StringOptionParser), \"Convert given conv layers to unshared local\", default=[])\n op.add_option(\"unshare-weights\", \"unshare_weights\", ListOptionParser(StringOptionParser), \"Unshare weight matrices in given layers\", default=[])\n op.add_option(\"conserve-mem\", \"conserve_mem\", BooleanOptionParser, \"Conserve GPU memory (slower)?\", default=0)\n op.add_option(\"color-noise\", \"color_noise\", FloatOptionParser, \"Add PCA noise to color channels with given scale\", default=0.0)\n op.add_option(\"test-out\", \"test_out\", StringOptionParser, \"Output test case predictions to given path\", default=\"\", requires=['logreg_name', 'multiview_test'])\n op.add_option(\"logreg-name\", \"logreg_name\", StringOptionParser, \"Logreg cost layer name (for --test-out)\", default=\"\")\n op.add_option(\"scalar-mean\", \"scalar_mean\", FloatOptionParser, \"Subtract this scalar from image (-1 = don't)\", default=-1)\n \n op.add_option(\"write-features\", \"write_features\", StringOptionParser, \"Write test data features from given layer\", default=\"\", requires=['feature-path'])\n op.add_option(\"feature-path\", \"feature_path\", StringOptionParser, \"Write test data features to this path (to be used with --write-features)\", default=\"\")\n\n op.delete_option('max_test_err')\n op.options[\"testing_freq\"].default = 57\n op.options[\"num_epochs\"].default = 50000\n op.options['dp_type'].default = None\n\n DataProvider.register_data_provider('dummy-lr-n', 'Dummy ConvNet logistic regression', DummyConvNetLogRegDataProvider)\n DataProvider.register_data_provider('image', 'JPEG-encoded image data provider', ImageDataProvider)\n DataProvider.register_data_provider('cifar', 'CIFAR-10 data provider', CIFARDataProvider)\n \n return op\n\nif __name__ == \"__main__\":\n# nr.seed(6)\n\n op = ConvNet.get_options_parser()\n\n op, load_dic = IGPUModel.parse_options(op)\n model = ConvNet(op, load_dic)\n model.start()\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconv3/Makefile", "content": "################################################################################\n#\n# Copyright 1993-2012 NVIDIA Corporation. All rights reserved.\n#\n# NOTICE TO USER: \n#\n# This source code is subject to NVIDIA ownership rights under U.S. and \n# international Copyright laws. \n#\n# NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE \n# CODE FOR ANY PURPOSE. IT IS PROVIDED \"AS IS\" WITHOUT EXPRESS OR \n# IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH \n# REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF \n# MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. \n# IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, \n# OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS \n# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE \n# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE \n# OR PERFORMANCE OF THIS SOURCE CODE. \n#\n# U.S. Government End Users. This source code is a \"commercial item\" as \n# that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of \n# \"commercial computer software\" and \"commercial computer software \n# documentation\" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) \n# and is provided to the U.S. Government only as a commercial end item. \n# Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through \n# 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the \n# source code with only those rights set forth herein.\n#\n################################################################################\n\n# Location of the CUDA Toolkit binaries and libraries\nCUDA_INC_PATH = $(CUDA_INSTALL_PATH)/include\nCUDA_BIN_PATH = $(CUDA_INSTALL_PATH)/bin\nCUDA_LIB_PATH = $(CUDA_INSTALL_PATH)/lib64\n\n# Common binaries\nNVCC = $(CUDA_BIN_PATH)/nvcc\nGCC = g++\nAR\t\t\t\t= ar\n\n# CUDA code generation flags\nGENCODE_SM35 := -gencode arch=compute_35,code=sm_35\nGENCODE_FLAGS := $(GENCODE_SM35)\n\nLDFLAGS := -L$(CUDA_LIB_PATH) -lcudart\nCCFLAGS := -m64\nNVCCFLAGS := -m64\n\n# Debug build flags\nifeq ($(dbg),1)\n CCFLAGS += -g\n NVCCFLAGS += -g -G\n DBG := debug\nelse\n DBG := release\n NVCCFLAGS += -O3\n CCFLAGS += -O3\nendif\n\n# Add profiler output\nifeq ($(prof),1)\n\tNVCCFLAGS += --ptxas-options=-v\nendif\n\nTARGETDIR := ./bin/$(DBG)\nOBJDIR := ./obj/$(DBG)\n\n########## USER STUFF ###########\nLDFLAGS \t\t+= -L../util -lutilpy -L../nvmatrix -lnvmatrix -lcublas\nINCLUDES \t:= -I$(CUDA_INC_PATH) -I $(CUDA_SDK_PATH)/common/inc -I./include\n\nCUFILES\t:= $(shell find . -name \"*.cu\")\nCU_DEPS\t:= $(shell find . -name \"*.cuh\")\nCCFILES\t:= $(shell find . -name \"*.cpp\")\nC_DEPS\t:= $(shell find . -name \"*.h\")\n\nNVCCFLAGS += --compiler-options '-fPIC'\nLDFLAGS += -shared\nCCFLAGS += -fPIC\nTARGET := $(TARGETDIR)/libcudaconv.so\n\n################################################################################\n# Set up target and object files\n################################################################################\nOBJS += $(patsubst %.cpp,$(OBJDIR)/%.cpp.o,$(CCFILES))\nOBJS += $(patsubst %.c,$(OBJDIR)/%.c.o,$(CFILES))\nOBJS += $(patsubst %.cu,$(OBJDIR)/%.cu.o,$(CUFILES))\n\n# Target rules\nall: makedirs $(TARGET)\n\n$(OBJDIR)/%.cu.o : %.cu $(CU_DEPS)\n\t$(NVCC) $(NVCCFLAGS) $(GENCODE_FLAGS) $(INCLUDES) -o $@ -c $<\n\n$(OBJDIR)/%.cpp.o : %.cpp $(C_DEPS)\n\t$(GCC) $(CCFLAGS) $(INCLUDES) -o $@ -c $<\n\n$(TARGET): $(OBJS)\n\t$(GCC) $(CCFLAGS) -o $@ $+ $(LDFLAGS) \n\tln -sf $(TARGET) .\n\nmakedirs:\n\tmkdir -p $(TARGETDIR)\n\tmkdir -p $(OBJDIR)/src\n\nclean:\n\trm -rf ./obj\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconv3/include/conv_util.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef CONV_UTIL_CUH\n#define\tCONV_UTIL_CUH\n\n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n\n#include \"caffe2/core/context_gpu.h\"\n\n#ifndef MIN\n#define MIN(a, b) ((a) > (b) ? (b) : (a))\n#endif\n#ifndef MAX\n#define MAX(a, b) ((a) > (b) ? (a) : (b))\n#endif\n\nvoid convLocalMaxUndo(NVMatrix& images, NVMatrix& maxGrads, NVMatrix& maxActs, NVMatrix& target,\n int subsX, int startX, int strideX, int outputsX);\nvoid convLocalAvgUndo(NVMatrix& avgGrads, NVMatrix& target,\n int subsX, int startX, int strideX, int outputsX, int imgSize, bool sum);\n\nvoid convLocalAvgUndo(NVMatrix& avgGrads, NVMatrix& target,\n int subsX, int startX, int strideX, int outputsX, int imgSize, bool sum,\n float scaleTargets, float scaleOutput);\nvoid convLocalMaxUndo(NVMatrix& images, NVMatrix& maxGrads, NVMatrix& maxActs, NVMatrix& target,\n int subsX, int startX, int strideX, int outputsX, float scaleTargets, float scaleOutput);\n\nvoid convResponseNorm(NVMatrix& images, NVMatrix& denoms, NVMatrix& target, int numFilters, int sizeX, float addScale, float powScale, float minDiv);\nvoid convResponseNormUndo(NVMatrix& outGrads, NVMatrix& denoms, NVMatrix& inputs, NVMatrix& acts, NVMatrix& target, int numFilters,\n int sizeX, float addScale, float powScale, float scaleTargets, float scaleOutput);\nvoid convContrastNorm(NVMatrix& images, NVMatrix& meanDiffs, NVMatrix& denoms, NVMatrix& target, int numFilters, int sizeX, float addScale, float powScale, float minDiv);\nvoid convContrastNormUndo(NVMatrix& outGrads, NVMatrix& denoms, NVMatrix& meanDiffs, NVMatrix& acts, NVMatrix& target, int numFilters,\n int sizeX, float addScale, float powScale, float scaleTargets, float scaleOutput);\n\nvoid convGaussianBlur(NVMatrix& images, NVMatrix& filter, NVMatrix& target, bool horiz, int numChannels,\n float scaleTargets, float scaleOutputs);\nvoid convBedOfNails(NVMatrix& images, NVMatrix& target, int numChannels, int imgSize, int startX,\n int strideX, float scaleTargets, float scaleOutput);\nvoid convBedOfNailsUndo(NVMatrix& actsGrad, NVMatrix& target, int numChannels, int imgSize,\n int startX, int strideX, float scaleTargets, float scaleOutput);\n\nvoid convResizeBilinear(NVMatrix& images, NVMatrix& target, int imgSize, int tgtSize, float scale);\nvoid convRGBToYUV(NVMatrix& images, NVMatrix& target);\nvoid convRGBToLAB(NVMatrix& images, NVMatrix& target, bool center);\nvoid convCrop(NVMatrix& imgs, NVMatrix& target, int imgSize, int tgtSize, int startY, int startX);\nvoid normalizeLocalWeights(NVMatrix& weights, int numModules, float norm);\nvoid convContrastNormCrossMap(NVMatrix& images, NVMatrix& meanDiffs, NVMatrix& target,\n int numFilters, int sizeF, float addScale, float powScale, float minDiv, bool blocked);\nvoid convResponseNormCrossMapUndo(NVMatrix& outGrads, NVMatrix& inputs, NVMatrix& acts, NVMatrix& target, int numFilters,\n int sizeF, float addScale, float powScale, float minDiv, bool blocked, float scaleTargets, float scaleOutput);\nvoid convResponseNormCrossMap(NVMatrix& images, NVMatrix& target, int numFilters, int sizeF, float addScale,\n float powScale, bool blocked);\nvoid convResponseNormCrossMap(NVMatrix& images, NVMatrix& target, int numFilters, int sizeF, float addScale,\n float powScale, float minDiv, bool blocked);\nvoid convReflectHorizontal(NVMatrix& images, NVMatrix& targets, int imgSize);\n\nvoid convCrossMapMaxPoolUndo(NVMatrix& images, NVMatrix& maxGrads, NVMatrix& maxActs, NVMatrix& target,\n const int imgSize, const int startF, const int poolSize,\n const int stride, const float scaleTargets, const float scaleOutputs);\n\ncudaTextureObject_t GetTensorTextureObject(caffe2::TensorCUDA* tensor);\n\ntemplate\nclass AvgPooler {\npublic:\n __device__ inline float operator()(const float a, const float b) const {\n return a + b;\n }\n __device__ inline float getBaseValue() const {\n return 0;\n }\n __device__ inline float output(const float a, const int regionSize) const {\n return sum ? a : (a / regionSize);\n }\n};\n\nclass MaxPooler {\npublic:\n __device__ inline float operator()(const float a, const float b) const {\n return fmaxf(a, b);\n }\n __device__ inline float getBaseValue() const {\n return -2e38;\n }\n __device__ inline float output(const float a, const int regionSize) const {\n return a;\n }\n};\n\nclass MaxAbsPooler {\npublic:\n __device__ inline float operator()(const float a, const float b) const {\n return fabsf(a) > fabsf(b) ? a : b;\n }\n __device__ inline float getBaseValue() const {\n return 0.0f;\n }\n __device__ inline float output(const float a, const int regionSize) const {\n return a;\n }\n};\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines output.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines output.y, filter idx in batches of B_Y*filtersPerThread\n *\n * So each block does one output for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * target: (numFilters, numOutputs, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n */\n\ntemplate\n__global__ void kLocalPool(float* imgs, float* target, const int imgSize, const int numFilters,\n const int numImages, const int subsX, const int startX, const int strideX,\n const int outputsX, Agg agg) {\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int numFilterBlocks = DIVUP(numFilters, B_Y*filtersPerThread);\n const int outputIdxX = blockIdx.x / numImgBlocks;\n const int outputIdxY = blockIdx.y / numFilterBlocks;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockFilterIdx = (blockIdx.y % numFilterBlocks) * B_Y * filtersPerThread;\n const int myFilterIdx = (blockFilterIdx + threadIdx.y*filtersPerThread);\n if (myFilterIdx >= numFilters) {\n return;\n }\n\n const int outputIdx = outputIdxY * outputsX + outputIdxX;\n const int numOutputs = outputsX * outputsX;\n const int imgPixels = imgSize * imgSize;\n\n const int startImgPxX = startX + outputIdxX * strideX;\n const int startImgPxY = startX + outputIdxY * strideX;\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n imgs += myFilterIdx * imgPixels * numImages + imgIdx;\n target += (myFilterIdx * numOutputs + outputIdx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[f][i] = agg.getBaseValue();\n }\n }\n\n const int loopStartY = MAX(0, startImgPxY);\n const int loopStartX = MAX(0, startImgPxX);\n const int loopEndY = MIN(imgSize, startImgPxY + subsX);\n const int loopEndX = MIN(imgSize, startImgPxX + subsX);\n const int regionSize = (loopEndY - loopStartY) * (loopEndX - loopStartX);\n for (int y = loopStartY; y < loopEndY; y++) {\n for (int x = loopStartX; x < loopEndX; x++) {\n const int imgPx = y * imgSize + x;\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] = agg(prod[f][i], imgs[(f * imgPixels + imgPx) * numImages + i * B_X]);\n }\n }\n }\n }\n }\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n target[f * numOutputs * numImages + i * B_X] = agg.output(prod[f][i], regionSize);\n }\n }\n }\n}\n\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, output idx in batches of B_Y\n *\n * So each block does one pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines output idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * target: (numOutputs, imgPixels, numImages) (out)\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n */\ntemplate\n__global__ void kPoolCrossMap(float* imgs, float* target, const int imgSize,\n const int numFilters, const int numImages, const int startF, const int poolSize,\n const int numOutputs, const int stride, Agg agg) {\n const int imgPixels = imgSize * imgSize;\n const int numImgBlocks = DIVUP(numImages, B_X*imgsPerThread);\n// const int numOutputs = DIVUP(numFilters, stride);\n const int numOutputBlocks = DIVUP(numOutputs,B_Y);\n const int pxIdxX = blockIdx.x / numImgBlocks;\n const int pxIdxY = blockIdx.y / numOutputBlocks;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int outputIdx = (blockIdx.y % numOutputBlocks) * B_Y + threadIdx.y;\n// const int filterIdx = outputIdx * stride;\n\n const int pxIdx = pxIdxY * imgSize + pxIdxX;\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n if (outputIdx < numOutputs) {\n imgs += (pxIdx) * numImages + imgIdx;\n target += (outputIdx * imgPixels + pxIdx) * numImages + imgIdx;\n\n float prod[imgsPerThread];\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[i] = agg.getBaseValue();\n }\n }\n\n const int myStartF = startF + outputIdx * stride;\n const int loopStartF = max(0, myStartF);\n const int loopEndF = min(numFilters, myStartF + poolSize);\n\n for (int f = loopStartF; f < loopEndF; ++f) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[i] = agg(prod[i], imgs[f * imgPixels * numImages + i * B_X]);\n }\n }\n }\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n target[i * B_X] = agg.output(prod[i], poolSize);\n }\n }\n }\n}\n\n/*\n * imgs: (numFilters, imgPixels, numImages)\n * target: (numOutputs, imgPixels, numImages)\n */\ntemplate\nvoid convPoolCrossMap(NVMatrix& images, NVMatrix& target, const int startF, const int poolSize,\n const int numOutputs, const int stride, const int imgSize, Pooler pooler) {\n int numImages = images.getNumCols();\n int imgPixels = imgSize * imgSize;\n int numFilters = images.getNumRows() / imgPixels;\n assert(images.getNumRows() == numFilters * imgPixels);\n\n assert(!images.isTrans());\n assert(!target.isTrans());\n assert(images.isContiguous());\n// assert(numFilters % 4 == 0);\n// assert(numImages % 128 == 0);\n assert(stride <= poolSize);\n assert(startF <= 0);\n assert(startF + (numOutputs-1) * stride + poolSize >= numFilters); // All filters must be covered\n\n cudaStream_t stream = NVMatrix::getDefaultStream();\n target.resize(imgPixels*numOutputs, numImages);\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n\n dim3 threads(32, 4);\n dim3 blocks(imgSize * DIVUP(numImages, threads.x * imgsPerThread), imgSize * DIVUP(numOutputs, threads.y));\n bool checkCaseBounds = numImages % (threads.x*imgsPerThread) != 0;\n if (!checkCaseBounds) {\n if (imgsPerThread == 4) {\n cudaFuncSetCacheConfig(kPoolCrossMap, cudaFuncCachePreferShared);\n kPoolCrossMap<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride, pooler);\n\n } else if (imgsPerThread == 2) {\n cudaFuncSetCacheConfig(kPoolCrossMap, cudaFuncCachePreferShared);\n kPoolCrossMap<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride, pooler);\n\n } else if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kPoolCrossMap, cudaFuncCachePreferShared);\n kPoolCrossMap<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride, pooler);\n }\n } else {\n if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kPoolCrossMap, cudaFuncCachePreferShared);\n kPoolCrossMap<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride, pooler);\n } else {\n assert(false);\n }\n }\n getLastCudaError(\"convPoolCrossMap: kernel execution failed\");\n}\n\n/*\n * Block size 16xB_X\n * blockIdx.x determines 4x4 pixel.x region, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines 4x4 pixel.y region, filter idx in batches of filtersPerThread\n *\n * So each block does a 4x4 region for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines pixel idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * target: (numFilters, numOutputs, numImages)\n *\n * B_X one of 8, 16, 32\n * imgsPerThread one of 1, 2, 4, 8, 16\n *\n * B_XximgsPerThread MUST be divisible by 32.\n * Number of filters MUST be divisible by filtersPerThread.\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n *\n * Final write-out will not be fully coalesced unless B_X is 32. But there's a lot more\n * reading than writing here, and the reading is all coalesced, so it should be OK.\n *\n * To be used when the stride is 1 and the pooling region is fairly large.\n */\ntemplate\n__global__ void kLocalPool2(float* imgs, float* target, const int imgSize, const int numFilters,\n const int numImages, const int subsX, const int startX,\n const int outputsX, Agg agg) {\n __shared__ float shImgs[filtersPerThread][B_X*imgsPerThread];\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int numFilterBlocks = numFilters/(filtersPerThread);\n const int blockOutputX = 4*(blockIdx.x / numImgBlocks);\n const int blockOutputY = 4*(blockIdx.y / numFilterBlocks);\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockFilterIdx = (blockIdx.y % numFilterBlocks) * filtersPerThread;\n\n// const int blockOutputIdx = blockOutputY * outputsX + blockOutputX;\n const int numOutputs = outputsX * outputsX;\n const int imgPixels = imgSize * imgSize;\n\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n const int loadY = tidx / 32, loadX = tidx % 32;\n\n const int myX = threadIdx.y % 4;\n const int myY = threadIdx.y / 4;\n\n const int myOutputIdxY = blockOutputY + myY;\n const int myOutputIdxX = blockOutputX + myX;\n const int myOutputIdx = myOutputIdxY * outputsX + myOutputIdxX;\n\n const int startImgPxX = startX + blockOutputX;\n const int startImgPxY = startX + blockOutputY;\n const int endImgPxX = startImgPxX + subsX;\n const int endImgPxY = startImgPxY + subsX;\n\n const int myStartImgPxY = startImgPxY + myY;\n const int myStartImgPxX = startImgPxX + myX;\n const int myEndImgPxY = endImgPxY + myY;\n const int myEndImgPxX = endImgPxX + myX;\n\n const int loopStartY = MAX(startImgPxY, 0);\n const int loopStartX = MAX(startImgPxX, 0);\n const int loopEndY = MIN(imgSize, endImgPxY + 3);\n const int loopEndX = MIN(imgSize, endImgPxX + 3);\n\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n imgs += (blockFilterIdx + loadY) * imgPixels * numImages + blockImgIdx + loadX;\n target += (blockFilterIdx * numOutputs + myOutputIdx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[f][i] = agg.getBaseValue();\n }\n }\n int regionSize = 0;\n for (int y = loopStartY; y < loopEndY; y++) {\n const bool isInY = y >= myStartImgPxY && y < myEndImgPxY ;\n for (int x = loopStartX; x < loopEndX; x++) {\n // Load a pixel\n const int px = y * imgSize + x;\n #pragma unroll\n for (int ly = 0; ly < filtersPerThread; ly += B_X/2) {\n if (filtersPerThread % (B_X/2) == 0 || ly + loadY < filtersPerThread) {\n #pragma unroll\n for (int lx = 0; lx < B_X*imgsPerThread; lx += 32) {\n if (!checkCaseBounds || lx + loadX + blockImgIdx < numImages) {\n shImgs[ly + loadY][lx + loadX] = imgs[(ly * imgPixels + px) * numImages + lx];\n }\n }\n }\n }\n __syncthreads();\n\n // Is this pixel in my region?\n if (isInY && x >= myStartImgPxX && x < myEndImgPxX) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] = agg(prod[f][i], shImgs[f][threadIdx.x + i * B_X]);\n }\n }\n }\n ++regionSize;\n }\n __syncthreads();\n\n }\n }\n if (myOutputIdxY < outputsX && myOutputIdxX < outputsX) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n target[f * numOutputs * numImages + i * B_X] = agg.output(prod[f][i], regionSize);\n }\n }\n }\n }\n}\n\n/*\n * imgs: (numFilters, imgPixels, numImages)\n * target: (numFilters, outputs, numImages)\n */\ntemplate\nvoid convLocalPool(NVMatrix& images, NVMatrix& target, int numFilters,\n int subsX, int startX, int strideX, int outputsX, Pooler pooler) {\n int numImages = images.getNumCols();\n int imgPixels = images.getNumRows() / numFilters;\n assert(images.getNumRows() == numFilters * imgPixels);\n int imgSize = int(sqrt(imgPixels));\n assert(imgSize * imgSize == imgPixels);\n\n assert(!images.isTrans());\n assert(!target.isTrans());\n assert(images.isContiguous());\n// assert(numFilters % 4 == 0);\n// assert(numImages % 128 == 0);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n int outputs = outputsX * outputsX;\n target.resize(numFilters*outputs, numImages);\n\n if (strideX == 1 && subsX >= 6 && outputsX > 1) {\n // NOTE: this part has not been optimized for Kepler\n int imgsPerThread = numImages % 128 == 0 ? 8 : 4;\n int filtersPerThread = numFilters % 4 == 0 ? 4 : numFilters % 3 == 0 ? 3 : numFilters % 2 == 0 ? 2 : 1;\n int bx = 8;\n bool checkCaseBounds = numImages % (bx*imgsPerThread) != 0;\n assert((imgsPerThread * bx) % 32 == 0);\n assert(numFilters % filtersPerThread == 0);\n dim3 threads(bx, 16);\n dim3 blocks(DIVUP(outputsX, 4) * DIVUP(numImages, bx*imgsPerThread), DIVUP(outputsX, 4) * numFilters / filtersPerThread);\n// printf(\"threads: %dx%d, blocks: %dx%d, imgSize: %d, numFilters: %d, numImages: %d, subsX: %d, startX: %d, outputsX: %d\\n\",\n// threads.y, threads.x, blocks.y, blocks.x, imgSize, numFilters, numImages, subsX, startX, outputsX);\n if (imgsPerThread == 8) {\n if (filtersPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n } else if (filtersPerThread == 2) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n } else if (filtersPerThread == 3) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n } else if (filtersPerThread == 4) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n }\n } else if (imgsPerThread == 4) {\n if (filtersPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n } else if (filtersPerThread == 2) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n } else if (filtersPerThread == 3) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n } else if (filtersPerThread == 4) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool2, cudaFuncCachePreferShared);\n kLocalPool2<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, outputsX, pooler);\n }\n }\n }\n } else {\n int filtersPerThread = numFilters % 16 == 0 ? 4 : 1;\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n bool checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages,32*imgsPerThread) * outputsX, DIVUP(numFilters, 4 * filtersPerThread) * outputsX);\n if (imgsPerThread == 4) {\n if (filtersPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n }\n }\n } else if (imgsPerThread == 2) {\n if (filtersPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n }\n }\n } else {\n if (filtersPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n } else {\n cudaFuncSetCacheConfig(kLocalPool, cudaFuncCachePreferL1);\n kLocalPool<<>>(images.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, pooler);\n }\n }\n }\n }\n getLastCudaError(\"convLocalPool: kernel execution failed\");\n}\n\n#endif\t/* CONV_UTIL_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconv3/include/cudaconv2.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef COMMON_CUH\n#define COMMON_CUH\n\n#include // helper functions CUDA error checking and initialization\n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"conv_util.cuh\"\n\n#include \"caffe2/core/context_gpu.h\"\n\nenum FILTER_OUTPUT_ORDER { MODULE_FILTER_IMAGE, FILTER_MODULE_IMAGE };\n\nvoid convFilterActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups);\nvoid convFilterActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups,\n float scaleTargets,\n float scaleOutput);\n\nvoid localFilterActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups);\nvoid localFilterActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups,\n float scaleTargets,\n float scaleOutput);\n\nvoid convImgActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int imgSizeX,\n int numModulesY,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups);\nvoid convImgActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int imgSizeX,\n int numModulesY,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups,\n float scaleTargets,\n float scaleOutput);\n\nvoid localImgActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int imgSizeX,\n int numModulesY,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups);\nvoid localImgActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* filters,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int imgSizeX,\n int numModulesY,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups,\n float scaleTargets,\n float scaleOutput);\n\nvoid convWeightActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int filterSize,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups,\n int sumWidth);\nvoid convWeightActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int filterSize,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups,\n int sumWidth,\n float scaleTargets,\n float scaleOutput);\n\nvoid localWeightActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int filterSize,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups);\n\nvoid localWeightActs(\n caffe2::CUDAContext* context,\n caffe2::TensorCUDA* images,\n caffe2::TensorCUDA* hidActs,\n caffe2::TensorCUDA* targets,\n int imgSizeY,\n int numModulesY,\n int numModulesX,\n int filterSize,\n int paddingStart,\n int moduleStride,\n int numImgColors,\n int numGroups,\n float scaleTargets,\n float scaleOutput);\n\n#endif /* COMMON_CUH */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/conv_util.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n\n#include \"../../nvmatrix/include/nvmatrix_kernels.cuh\"\n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"../include/conv_util.cuh\"\n\nusing namespace std;\n\n__device__ inline float square(const float a) {\n return a * a;\n}\n\n/*\n * Horizontal reflection.\n * imgs: (numColors, imgSize, imgSize, numCases)\n * targets: (numColors, imgSize, imgSize, numCases)\n *\n * targets should be a different array from imgs.\n *\n * Block size: (4, 32)\n * blockIdx.y * 4 + threadIdx.y determines pixel\n * blockIdx.x * 32 * imgsPerThread + threadIdx.x determines case batch\n *\n */\ntemplate\n__global__ void kReflectH(float * imgs, float * targets,\n const int imgSize, const int numCases) {\n const int pxIdx = blockIdx.y * 4 + threadIdx.y;\n const int imgPixels = imgSize * imgSize;\n\n if (pxIdx < imgPixels) {\n const int caseIdx = blockIdx.x * 32 * imgsPerThread + threadIdx.x;\n const int pxIdxY = pxIdx / imgSize;\n const int pxIdxX = pxIdx % imgSize;\n\n const int pxIdxXR = imgSize - 1 - pxIdxX; // reflected coordinate\n const int pxIdxR = pxIdxY * imgSize + pxIdxXR;\n\n imgs += pxIdx * numCases + caseIdx;\n targets += pxIdxR * numCases + caseIdx;\n\n#pragma unroll\n for (int i = 0; i < imgsPerThread; ++i) {\n if (!checkCaseBounds || caseIdx + i * 32 < numCases) {\n#pragma unroll\n for (int c = 0; c < numColors; ++c) {\n targets[c * imgPixels * numCases + i * 32] = imgs[c * imgPixels * numCases + i * 32];\n }\n }\n }\n }\n}\n/*\n * Horizontal reflection.\n * imgs: (numColors, imgSize, imgSize, numCases)\n * targets: (numColors, imgSize, imgSize, numCases)\n */\nvoid convReflectHorizontal(NVMatrix& images, NVMatrix& targets, int imgSize) {\n int numCases = images.getNumCols();\n int imgPixels = imgSize * imgSize;\n int numColors = images.getNumRows() / imgPixels;\n assert(numColors * imgPixels == images.getNumRows());\n assert(numColors > 0 && numColors <= 3);\n\n targets.resize(images);\n int imgsPerThread = numCases % 128 == 0 ? 4 : numCases % 64 == 0 ? 2 : 1;\n bool checkCaseBounds = numCases % (32 * imgsPerThread) != 0;\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numCases, imgsPerThread * 32), DIVUP(imgPixels, 4));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (checkCaseBounds) {\n if (numColors == 1) {\n if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kReflectH<1, 1, true>, cudaFuncCachePreferL1);\n kReflectH<1, 1, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 2) {\n cudaFuncSetCacheConfig(kReflectH<1, 2, true>, cudaFuncCachePreferL1);\n kReflectH<1, 2, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 4) {\n cudaFuncSetCacheConfig(kReflectH<1, 4, true>, cudaFuncCachePreferL1);\n kReflectH<1, 4, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n }\n } else if (numColors == 2) {\n if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kReflectH<2, 1, true>, cudaFuncCachePreferL1);\n kReflectH<2, 1, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 2) {\n cudaFuncSetCacheConfig(kReflectH<2, 2, true>, cudaFuncCachePreferL1);\n kReflectH<2, 2, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 4) {\n cudaFuncSetCacheConfig(kReflectH<2, 4, true>, cudaFuncCachePreferL1);\n kReflectH<2, 4, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n }\n } else if (numColors == 3) {\n if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kReflectH<3, 1, true>, cudaFuncCachePreferL1);\n kReflectH<3, 1, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 2) {\n cudaFuncSetCacheConfig(kReflectH<3, 2, true>, cudaFuncCachePreferL1);\n kReflectH<3, 2, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 4) {\n cudaFuncSetCacheConfig(kReflectH<3, 4, true>, cudaFuncCachePreferL1);\n kReflectH<3, 4, true><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n }\n }\n } else {\n if (numColors == 1) {\n if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kReflectH<1, 1, false>, cudaFuncCachePreferL1);\n kReflectH<1, 1, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 2) {\n cudaFuncSetCacheConfig(kReflectH<1, 2, false>, cudaFuncCachePreferL1);\n kReflectH<1, 2, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 4) {\n cudaFuncSetCacheConfig(kReflectH<1, 4, false>, cudaFuncCachePreferL1);\n kReflectH<1, 4, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n }\n } else if (numColors == 2) {\n if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kReflectH<2, 1, false>, cudaFuncCachePreferL1);\n kReflectH<2, 1, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 2) {\n cudaFuncSetCacheConfig(kReflectH<2, 2, false>, cudaFuncCachePreferL1);\n kReflectH<2, 2, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 4) {\n cudaFuncSetCacheConfig(kReflectH<2, 4, false>, cudaFuncCachePreferL1);\n kReflectH<2, 4, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n }\n } else if (numColors == 3) {\n if (imgsPerThread == 1) {\n cudaFuncSetCacheConfig(kReflectH<3, 1, false>, cudaFuncCachePreferL1);\n kReflectH<3, 1, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 2) {\n cudaFuncSetCacheConfig(kReflectH<3, 2, false>, cudaFuncCachePreferL1);\n kReflectH<3, 2, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n } else if (imgsPerThread == 4) {\n cudaFuncSetCacheConfig(kReflectH<3, 4, false>, cudaFuncCachePreferL1);\n kReflectH<3, 4, false><<>>(images.getDevData(), targets.getDevData(), imgSize, numCases);\n }\n }\n }\n getLastCudaError(\"kReflectH: kernel execution failed\");\n}\n\n/*\n * blockIdx.y determines module in batches of B_Y\n * blockIdx.x determines filter in batches of B_X * filtersPerThread\n *\n * weights: (numModules, numColors, filterPixels, numFilters)\n * Not fully coalesced if B_X < 32, so use cache.\n */\ntemplate \n__global__ void kNormalizeLCWeights(float* weights, const uint numFilters, const int numModules, const uint weightsPerFilter, const float norm) {\n const uint moduleIdx = B_Y * blockIdx.y + threadIdx.y;\n const uint filterIdx = B_X * blockIdx.x + threadIdx.x;\n\n float prod[filtersPerThread];\n #pragma unroll\n for (uint i = 0; i < filtersPerThread; ++i) {\n prod[i] = 0;\n }\n if (moduleIdx < numModules) {\n weights += moduleIdx * weightsPerFilter * numFilters + filterIdx;\n for (uint p = 0; p < weightsPerFilter; ++p) {\n #pragma unroll\n for (uint i = 0; i < filtersPerThread; ++i) {\n prod[i] += square(weights[p * numFilters + i * B_X]);\n }\n }\n\n #pragma unroll\n for (uint i = 0; i < filtersPerThread; ++i) {\n prod[i] = sqrtf(prod[i]);\n prod[i] = prod[i] > norm ? __fdividef(norm, prod[i]) : 1.0f;\n }\n\n for (uint p = 0; p < weightsPerFilter; ++p) {\n #pragma unroll\n for (uint i = 0; i < filtersPerThread; ++i) {\n weights[p * numFilters + i * B_X] *= prod[i];\n }\n }\n }\n}\n\n/*\n * weights: (numModules, numColors, filterPixels, numFilters)\n */\nvoid normalizeLocalWeights(NVMatrix& weights, int numModules, float norm) {\n int numFilters = weights.getNumCols();\n int weightsPerFilter = weights.getNumRows() / numModules;\n assert(numModules * weightsPerFilter == weights.getNumRows());\n\n assert(!weights.isTrans());\n assert(weights.isContiguous());\n assert(numFilters % 16 == 0);\n\n int bx = numFilters % 32 == 0 ? 32 : 16;\n int by = bx == 32 ? 4 : 8;\n\n int filtersPerThread = numFilters % 128 == 0 ? 4 : numFilters % 64 == 0 ? 2 : 1;\n dim3 blocks(numFilters / (bx * filtersPerThread), DIVUP(numModules, by));\n dim3 threads(bx, by);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (filtersPerThread == 4) {\n cudaFuncSetCacheConfig(kNormalizeLCWeights<4, 32, 4>, cudaFuncCachePreferL1);\n kNormalizeLCWeights<4, 32, 4><<>>(weights.getDevData(), numFilters, numModules, weightsPerFilter, norm);\n } else if (filtersPerThread == 2) {\n cudaFuncSetCacheConfig(kNormalizeLCWeights<4, 32, 2>, cudaFuncCachePreferL1);\n kNormalizeLCWeights<4, 32, 2><<>>(weights.getDevData(), numFilters, numModules, weightsPerFilter, norm);\n } else {\n if (numFilters % 32 == 0) {\n cudaFuncSetCacheConfig(kNormalizeLCWeights<4, 32, 1>, cudaFuncCachePreferL1);\n kNormalizeLCWeights<4, 32, 1><<>>(weights.getDevData(), numFilters, numModules, weightsPerFilter, norm);\n } else {\n cudaFuncSetCacheConfig(kNormalizeLCWeights<8, 16, 1>, cudaFuncCachePreferL1);\n kNormalizeLCWeights<8, 16, 1><<>>(weights.getDevData(), numFilters, numModules, weightsPerFilter, norm);\n }\n }\n}\n\n/*\n * Block size 4x32\n * blockIdx.x determines img idx in batches of 32*imgsPerThread\n * blockIdx.y determines channel idx, pixel idx in batches of 4\n *\n * threadIdx.x determins case idx\n * threadIdx.y determines pixel idx\n *\n * imgs: (numChannels, imgPixels, numImages) with given imgStride\n * target: (numChannels, tgtPixels, numImages)\n */\ntemplate \n__global__ void kCrop(float* imgs, float* target, const uint numImages, const int imgStride,\n const uint imgSize, const uint tgtSize, const uint startY, const uint startX) {\n const uint imgPixels = imgSize * imgSize;\n const uint tgtPixels = tgtSize * tgtSize;\n const uint caseIdx = blockIdx.x * 32 * imgsPerThread + threadIdx.x;\n const uint blockChanIdx = blockIdx.y / DIVUP(tgtPixels, 4);\n const uint tgtPixelIdx = 4*(blockIdx.y % DIVUP(tgtPixels, 4)) + threadIdx.y;\n const uint tgtPxY = tgtPixelIdx / tgtSize;\n const uint tgtPxX = tgtPixelIdx % tgtSize;\n const uint srcPixelIdx = (startY + tgtPxY) * imgSize + startX + tgtPxX;\n\n if (tgtPixelIdx < tgtPixels) {\n imgs += (blockChanIdx * imgPixels + srcPixelIdx) * imgStride + caseIdx;\n target += (blockChanIdx * tgtPixels + tgtPixelIdx) * numImages + caseIdx;\n\n #pragma unroll\n for (uint i = 0; i < imgsPerThread; ++i) {\n if (!checkCaseBounds || (caseIdx + 32 * i < numImages)) {\n target[i * 32] = imgs[i * 32];\n }\n }\n }\n}\n\n/*\n * Block size 4x32\n * blockIdx.y determines pixel idx in batches of 4\n * blockIdx.x determines case idx in batches of 32*imgsPerThread\n * threadIdx.y determines pixel idx\n * threadIdx.x determines case idx\n *\n * imgs: (3, imgPixels, numImages) with given imgStride\n * target: (3, imgPixels, numImages)\n *\n * Each thread produces (y,u,v) values for a particular (r,g,b) pixel\n *\n * The RGB --> YUV transform is (http://en.wikipedia.org/wiki/YUV):\n *\n * [Y] [ 0.2126 0.7152 0.0722 ][R]\n * [U] = [-0.09991 -0.33609 0.436 ][G]\n * [V] [ 0.615 -0.55861 -0.05639][B]\n */\ntemplate \n__global__ void kRGBToYUV(float* imgs, float* target, const int imgPixels, const int numImages, const int imgStride) {\n const int caseIdx = blockIdx.x * 32 * imgsPerThread + threadIdx.x;\n const int pxIdx = blockIdx.y * 4 + threadIdx.y;\n\n if (pxIdx < imgPixels) {\n const int imgChannelStride = imgPixels * imgStride;\n const int tgtChannelStride = imgPixels * numImages;\n imgs += pxIdx * imgStride + caseIdx;\n target += pxIdx * numImages + caseIdx;\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; ++i) {\n if (!checkCaseBounds || caseIdx + i * 32 < numImages) {\n const float R = imgs[0 * imgChannelStride + i * 32];\n const float G = imgs[1 * imgChannelStride + i * 32];\n const float B = imgs[2 * imgChannelStride + i * 32];\n target[0 * tgtChannelStride + i * 32] = 0.2126f * R + 0.7152f * G + 0.0722f * B; // Y\n target[1 * tgtChannelStride + i * 32] = -0.09991f * R + -0.33609f * G + 0.436f * B; // U\n target[2 * tgtChannelStride + i * 32] = 0.615f * R + -0.55861f * G + -0.05639f * B; // V\n }\n }\n }\n}\n\n__device__ inline float labf(const float x) {\n if (x > 0.0088564517f) {\n return __powf(x, 0.3333f);\n }\n return 7.787037f * x + 0.13793103f;\n}\n\n/*\n * Block size 4x32\n * blockIdx.y determines pixel idx in batches of 4\n * blockIdx.x determines case idx in batches of 32*imgsPerThread\n * threadIdx.y determines pixel idx\n * threadIdx.x determines case idx\n *\n * imgs: (3, imgPixels, numImages) with given imgStride\n * target: (3, imgPixels, numImages)\n *\n * This proceeds in two steps.\n *\n * - First, RGB values are linearly transformed to XYZ as per\n * http://en.wikipedia.org/wiki/CIE_XYZ_color_space\n * - Second, XYZ values are nonlinearly transformed to L*a*b* as per\n * http://en.wikipedia.org/wiki/Lab_color_space#The_forward_transformation\n *\n * Each thread produces (L*,a*,b*) values for a particular (r,g,b) pixel\n *\n * The RGB --> XYZ transform is:\n *\n * [X] [0.49 0.31 0.2 ][R]\n * [Y] = 5.6506753 * [0.17697 0.8124 0.01063 ][G]\n * [Z] [0 0.01 0.99 ][B]\n *\n * NOTE: The input should be in the range 0-1. Don't do mean-subtraction beforehand.\n *\n * Then X_max, Y_max, Z_max = 5.6506753.\n *\n * The range of the L* values is [0, 100].\n * If the center flag is given, the range will be [-50, 50].\n *\n */\ntemplate \n__global__ void kRGBToLAB(float* imgs, float* target, const int imgPixels, const int numImages, const int imgStride) {\n const int caseIdx = blockIdx.x * 32 * imgsPerThread + threadIdx.x;\n const int pxIdx = blockIdx.y * 4 + threadIdx.y;\n\n if (pxIdx < imgPixels) {\n const int imgChannelStride = imgPixels * imgStride;\n const int tgtChannelStride = imgPixels * numImages;\n imgs += pxIdx * imgStride + caseIdx;\n target += pxIdx * numImages + caseIdx;\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; ++i) {\n if (!checkCaseBounds || caseIdx + i * 32 < numImages) {\n const float R = imgs[0 * imgChannelStride + i * 32];\n const float G = imgs[1 * imgChannelStride + i * 32];\n const float B = imgs[2 * imgChannelStride + i * 32];\n\n const float X = (0.49f * R + 0.31f * G + 0.2f * B);\n const float Y = (0.17697f * R + 0.8124f * G + 0.01063f * B);\n const float Z = (0.01f * G + 0.99f * B);\n\n const float labX = labf(X);\n const float labY = labf(Y);\n const float labZ = labf(Z);\n\n target[0 * tgtChannelStride + i * 32] = 116.0f * labY - 16.0f - (center ? 50.0f : 0); // L*\n target[1 * tgtChannelStride + i * 32] = 500.0f * (labX - labY); // a*\n target[2 * tgtChannelStride + i * 32] = 200.0f * (labY - labZ); // b*\n }\n }\n }\n}\n\n/*\n * Block size 16x32.\n * Each block produces a 4x4 chunk of the output image.\n * threadIdx.y determines pixel idx in 4x4 chunk.\n * threadIdx.x determines case idx.\n * blockIdx.x determines case idx in batches of 32*imgsPerThread.\n * blockIdx.y determines 4x4 chunk idx, channel idx.\n *\n * imgs: (numChannels, imgPixels, numImages) with given imgStride\n * target: (numChannels, tgtPixels, numImages)\n *\n * imgSize = scale * tgtSize (roughly)\n *\n * This is a rather naive kernel that relies on cache for speed. But all it's doing\n * is basic texture manipulation, which is very local in nature, so it should be ok.\n * Also, it will in practice be a tiny fraction of the runtime of a large convnet.\n *\n * So that is my justification for being lazy here.\n */\ntemplate \n__global__ void kResizeBilinear(float* imgs, float* target, const int imgSize, const int tgtSize,\n const int numImages, const int imgStride, const float scale,\n const float centerScale) {\n const int numChunksX = DIVUP(tgtSize, 4);\n const int numChunks = numChunksX * numChunksX;\n const int channelIdx = blockIdx.y / numChunks;\n const int chunkIdx = blockIdx.y % numChunks;\n const int chunkIdxX = chunkIdx % numChunksX;\n const int chunkIdxY = chunkIdx / numChunksX;\n const int caseIdx = blockIdx.x * 32 * imgsPerThread + threadIdx.x;\n const int imgPixels = imgSize * imgSize;\n const int tgtPixels = tgtSize * tgtSize;\n\n const int pxX = 4 * chunkIdxX + threadIdx.y % 4;\n const int pxY = 4 * chunkIdxY + threadIdx.y / 4;\n\n if (pxY < tgtSize && pxX < tgtSize) {\n const int pxIdx = pxY * tgtSize + pxX;\n\n imgs += channelIdx * imgPixels * imgStride + caseIdx;\n target += channelIdx * tgtPixels * numImages + pxIdx * numImages + caseIdx;\n\n // This will cause slight distortions at the edges when upsampling in some cases.\n // But I think that's not a big deal.\n const float srcPxX = fmaxf(0.0f, fminf(__int2float_rn(imgSize) - 1.01f, __int2float_rn(pxX) * scale + centerScale));\n const float srcPxY = fmaxf(0.0f, fminf(__int2float_rn(imgSize) - 1.01f, __int2float_rn(pxY) * scale + centerScale));\n\n const float u = floorf(srcPxX + 1) - srcPxX;\n const float w = srcPxY - floorf(srcPxY);\n\n // Consider doing max(0, min(imgSize, x)) here\n const int srcPx0 = (__float2int_rd(srcPxY) * imgSize + __float2int_rd(srcPxX)); // top-left\n const int srcPx1 = srcPx0 + 1; // top-right\n const int srcPx2 = srcPx0 + imgSize; // bottom-left\n const int srcPx3 = srcPx2 + 1; // bottom-right\n\n #pragma unroll\n for (int c = 0; c < imgsPerThread; ++c) {\n if (!checkCaseBounds || caseIdx + c * 32 < numImages) {\n const float val0 = imgs[srcPx0 * imgStride + c * 32];\n const float val1 = imgs[srcPx1 * imgStride + c * 32];\n const float val2 = imgs[srcPx2 * imgStride + c * 32];\n const float val3 = imgs[srcPx3 * imgStride + c * 32];\n\n const float c0 = u * (val0 - val1) + val1;\n const float c1 = u * (val2 - val3) + val3;\n\n target[32 * c] = w * (c1 - c0) + c0;\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X.\n * B_X*imgsPerThread*blockIdx.x + threadIdx.x determines img idx\n * B_Y*blockIdx.y + threadIdx.y determines img row (col if !horiz), channel idx\n *\n * imgs: (numChannels, imgPixels, numImages) with given imgStride\n * filter: (1, 2*radius + 1)\n * target: (numChannels, imgPixels, numImages)\n *\n * target can be the same matrix as imgs.\n * radius must be one of 3, 5, 7, 9.\n *\n * Tried imgsPerThread, slower.\n */\ntemplate\n__global__ void kGaussianBlur(float* imgs, float* filter, float* target, const int imgSize,\n const int numImages, const int imgStride, const int numChannels,\n const bool horiz,\n const float scaleTargets, const float scaleOutputs) {\n const int filterWidth = 2*radius+1;\n __shared__ float shFilter[filterWidth-1];\n\n const int imgPixels = imgSize * imgSize;\n const int ty = B_Y * blockIdx.y + threadIdx.y;\n const int channelIdx = ty / imgSize;\n const int rowIdx = ty % imgSize;\n const int imgIdx = B_X*blockIdx.x + threadIdx.x;\n\n// const int tidx = B_Y * threadIdx.y + threadIdx.x;\n if (horiz) {\n imgs += channelIdx * imgPixels * imgStride + rowIdx * imgSize * imgStride + imgIdx;\n target += channelIdx * imgPixels * numImages + rowIdx * imgSize * numImages + imgIdx;\n } else {\n imgs += channelIdx * imgPixels * imgStride + rowIdx * imgStride + imgIdx;\n target += channelIdx * imgPixels * numImages + rowIdx * numImages + imgIdx;\n }\n float outputs[filterWidth-1];\n #pragma unroll\n for (int r = 0; r < filterWidth-1; r++) {\n outputs[r] = 0;\n }\n if (threadIdx.x < filterWidth-1) {\n shFilter[threadIdx.x] = filter[threadIdx.x];\n }\n __syncthreads();\n\n if (imgIdx < numImages && channelIdx < numChannels) {\n // This writes radius*2 = filterWidth - 1 values to outputs\n #pragma unroll\n for (int col = 0; col < radius; col++) {\n float px = imgs[0];\n #pragma unroll\n for (int r = 0; r < radius + 1 + col; r++) {\n outputs[r] += px * shFilter[radius + col - r];\n }\n imgs += horiz ? imgStride : imgStride * imgSize;\n }\n\n // Unfortunately this has to be at this level of granularity\n if (scaleTargets != 0) {\n for (int col = radius; col < imgSize ; col++) { // loop over img columns\n float px = imgs[0];\n target[0] = scaleTargets * target[0] + scaleOutputs * (outputs[0] + px * shFilter[0]);\n\n #pragma unroll\n for (int r = 1; r < radius*2; r++) {\n outputs[r-1] = outputs[r] + px * shFilter[r];\n }\n outputs[filterWidth - 2] = px * shFilter[0];\n\n imgs += horiz ? imgStride : imgStride * imgSize;\n target += horiz ? numImages : numImages * imgSize;\n }\n\n #pragma unroll\n for (int r = 0; r < radius; r++) {\n float* t = &target[0];\n t[0] = scaleTargets * t[0] + scaleOutputs * outputs[r];\n target += horiz ? numImages : numImages * imgSize;\n }\n } else {\n for (int col = radius; col < imgSize ; col++) { // loop over img columns\n float px = imgs[0];\n target[0] = scaleOutputs * (outputs[0] + px * shFilter[0]);\n #pragma unroll\n for (int r = 1; r < radius*2; r++) {\n outputs[r-1] = outputs[r] + px * shFilter[r];\n }\n outputs[filterWidth - 2] = px * shFilter[0];\n\n imgs += horiz ? imgStride : imgStride * imgSize;\n target += horiz ? numImages : numImages * imgSize;\n }\n\n #pragma unroll\n for (int r = 0; r < radius; r++) {\n target[0] = scaleOutputs * outputs[r];\n target += horiz ? numImages : numImages * imgSize;\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines output.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines output.y, filter idx in batches of B_Y*filtersPerThread\n *\n * So each block does one output for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * imgs: (numChannels, imgPixels, numImages)\n * target: (numChannels, numOutputs, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n * numFilters must be divisible by filtersPerThread\n */\n\ntemplate\n__global__ void kBedOfNails(float* imgs, float* target, const int imgSize, const int numChannels,\n const int numImages, const int startX, const int strideX, const int outputsX,\n const bool reverse, const float scaleTargets, const float scaleOutput) {\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int numChanBlocks = DIVUP(numChannels, B_Y*chansPerThread);\n const int outputIdxX = blockIdx.x / numImgBlocks;\n const int outputIdxY = blockIdx.y / numChanBlocks;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockChanIdx = (blockIdx.y % numChanBlocks) * B_Y * chansPerThread;\n const int myChanIdx = (blockChanIdx + threadIdx.y*chansPerThread);\n if (myChanIdx >= numChannels) {\n return;\n }\n// if (blockIdx.x != 0 || blockIdx.y != 0) {\n// return;\n// }\n const int outputIdx = outputIdxY * outputsX + outputIdxX;\n const int numOutputs = outputsX * outputsX;\n const int imgPixels = imgSize * imgSize;\n\n const int startImgPxX = startX + outputIdxX * strideX;\n const int startImgPxY = startX + outputIdxY * strideX;\n const int imgIdx = blockImgIdx + threadIdx.x;\n const int imgPx = startImgPxY * imgSize + startImgPxX;\n\n imgs += myChanIdx * imgPixels * numImages + imgPx * numImages + imgIdx;\n target += (myChanIdx * numOutputs + outputIdx) * numImages + imgIdx;\n\n if (scaleTargets != 0) {\n if (!reverse) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < chansPerThread; c++) {\n target[c * numOutputs * numImages + i * B_X] = scaleTargets * target[c * numOutputs * numImages + i * B_X] + scaleOutput * imgs[c * imgPixels * numImages + i * B_X];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < chansPerThread; c++) {\n imgs[c * imgPixels * numImages + i * B_X] = scaleTargets * imgs[c * imgPixels * numImages + i * B_X] + scaleOutput * target[c * numOutputs * numImages + i * B_X];\n }\n }\n }\n }\n } else {\n if (!reverse) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < chansPerThread; c++) {\n target[c * numOutputs * numImages + i * B_X] = scaleOutput * imgs[c * imgPixels * numImages + i * B_X];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < chansPerThread; c++) {\n imgs[c * imgPixels * numImages + i * B_X] = scaleOutput * target[c * numOutputs * numImages + i * B_X];\n }\n }\n }\n }\n }\n\n}\n\n/*\n * imgs: (numChannels, imgPixels, numImages)\n * target: (numChannels, outputs, numImages)\n */\nvoid _convBedOfNails(NVMatrix& images, NVMatrix& target, int numChannels, int imgSize, int startX, int strideX,\n bool reverse, float scaleTargets, float scaleOutput) {\n int numImages = reverse ? target.getNumCols() : images.getNumCols();\n int imgPixels = imgSize * imgSize;\n\n assert(!images.isTrans());\n assert(!target.isTrans());\n assert(images.isContiguous());\n assert(target.isContiguous());\n assert(strideX > 1);\n\n int outputsX = DIVUP(imgSize, strideX);\n int outputs = outputsX * outputsX;\n if (reverse) {\n assert(target.getNumRows() == numChannels * outputs);\n } else {\n assert(images.getNumRows() == numChannels * imgPixels);\n }\n\n if (scaleTargets == 0) {\n if (reverse) {\n images.resize(numChannels * imgPixels, numImages);\n images.apply(NVMatrixOps::Zero());\n } else {\n target.resize(numChannels*outputs, numImages);\n }\n } else {\n if (reverse) {\n assert(images.getNumRows() == numChannels * outputs);\n assert(images.getNumCols() == numImages);\n } else {\n assert(target.getNumRows() == numChannels * outputs);\n assert(target.getNumCols() == numImages);\n }\n }\n\n\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n bool checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n int chansPerThread = numChannels % 8 == 0 ? 2 : 1;\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages,32*imgsPerThread) * outputsX, DIVUP(numChannels, 4 * chansPerThread) * outputsX);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (imgsPerThread == 4) {\n if (chansPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 4, 1, true>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 4, 1, true><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 4, 1, false>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 4, 1, false><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 4, 2, true>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 4, 2, true><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 4, 2, false>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 4, 2, false><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n }\n }\n } else if (imgsPerThread == 2) {\n if (chansPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 2, 1, true>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 2, 1, true><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 2, 1, false>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 2, 1, false><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 2, 2, true>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 2, 2, true><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 2, 2, false>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 2, 2, false><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n }\n }\n } else {\n if (chansPerThread == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 1, 1, true>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 1, 1, true><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 1, 1, false>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 1, 1, false><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 1, 2, true>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 1, 2, true><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kBedOfNails<4, 32, 1, 2, false>, cudaFuncCachePreferL1);\n kBedOfNails<4, 32, 1, 2, false><<>>(images.getDevData(), target.getDevData(),\n imgSize, numChannels, numImages, startX, strideX, outputsX,\n reverse, scaleTargets, scaleOutput);\n }\n }\n }\n}\n\nvoid convBedOfNails(NVMatrix& images, NVMatrix& target, int numChannels, int imgSize, int startX,\n int strideX, float scaleTargets, float scaleOutput) {\n _convBedOfNails(images, target, numChannels, imgSize, startX, strideX, false, scaleTargets, scaleOutput);\n}\n\nvoid convBedOfNailsUndo(NVMatrix& actsGrad, NVMatrix& target, int numChannels, int imgSize,\n int startX, int strideX, float scaleTargets, float scaleOutput) {\n\n _convBedOfNails(target, actsGrad, numChannels, imgSize, startX, strideX, true, scaleTargets, scaleOutput);\n}\n\n\n/*\n * imgs: (numChannels, imgPixels, numImages) with given imgStride\n * filter: (1, 2*radius + 1)\n * target: (numChannels, imgPixels, numImages)\n */\nvoid convGaussianBlur(NVMatrix& images, NVMatrix& filter, NVMatrix& target, bool horiz, int numChannels,\n float scaleTargets, float scaleOutputs) {\n int numImages = images.getNumCols();\n int radius = filter.getNumCols() / 2;\n int imgPixels = images.getNumRows() / numChannels;\n int imgSize = int(sqrt(imgPixels));\n\n assert(imgPixels == imgSize * imgSize);\n assert(radius >= 1 && radius <= 4);\n assert(imgSize >= 2 * radius + 1);\n assert(filter.getNumRows() == 1);\n assert(images.getNumRows() == numChannels * imgPixels);\n assert(!images.isTrans());\n assert(!filter.isTrans());\n assert(!target.isTrans());\n assert(target.isContiguous());\n if (scaleTargets == 0) {\n target.resize(images);\n } else {\n assert(target.isSameDims(images));\n }\n\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages, threads.x), DIVUP(numChannels*imgSize, threads.y));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (radius == 1) {\n cudaFuncSetCacheConfig(kGaussianBlur<4, 32, 1>, cudaFuncCachePreferL1);\n kGaussianBlur<4, 32, 1><<>>(images.getDevData(), filter.getDevData(), target.getDevData(),\n imgSize, numImages, images.getStride(), numChannels, horiz, scaleTargets, scaleOutputs);\n\n } else if (radius == 2) {\n cudaFuncSetCacheConfig(kGaussianBlur<4, 32, 2>, cudaFuncCachePreferL1);\n kGaussianBlur<4, 32, 2><<>>(images.getDevData(), filter.getDevData(), target.getDevData(),\n imgSize, numImages, images.getStride(), numChannels,horiz, scaleTargets, scaleOutputs);\n\n } else if (radius == 3) {\n cudaFuncSetCacheConfig(kGaussianBlur<4, 32, 3>, cudaFuncCachePreferL1);\n kGaussianBlur<4, 32, 3><<>>(images.getDevData(), filter.getDevData(), target.getDevData(),\n imgSize, numImages, images.getStride(), numChannels,horiz, scaleTargets, scaleOutputs);\n } else if (radius == 4) {\n cudaFuncSetCacheConfig(kGaussianBlur<4, 32, 4>, cudaFuncCachePreferL1);\n kGaussianBlur<4, 32, 4><<>>(images.getDevData(), filter.getDevData(), target.getDevData(),\n imgSize, numImages, images.getStride(), numChannels,horiz, scaleTargets, scaleOutputs);\n }\n}\n\n/*\n * Block size 1x128\n * blockIdx.x determines pixel.x, image idx in batches of 128*imgsPerThread\n * blockIdx.y determines pixel.y\n *\n * So each block does one output for some number of images and all the fliters.\n *\n * threadIdx.x determines img idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * meanDiffs: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages) (out)\n * target: (numFilters, imgPixels, numImages) (out)\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n * numFilters must be divisible by B_Y*filtersPerThread\n */\n\ntemplate\n__global__ void kCNorm_fewfilter(float* imgs, float* meanDiffs, float* denoms, float* target, const int imgSize,\n const int numImages, const int sizeX, const float addScale, const float powScale, const float minDiv) {\n\n const int imgPixels = imgSize * imgSize;\n const int numImgBlocks = DIVUP(numImages, 128*imgsPerThread);\n const int pxIdxX = blockIdx.x / numImgBlocks;\n const int pxIdxY = blockIdx.y;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * 128 * imgsPerThread;\n\n const int pxIdx = pxIdxY * imgSize + pxIdxX;\n\n const int startPxX = -sizeX/2 + pxIdxX;\n const int startPxY = -sizeX/2 + pxIdxY;\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n imgs += pxIdx * numImages + imgIdx;\n denoms += pxIdx * numImages + imgIdx;\n meanDiffs += imgIdx;\n target += pxIdx * numImages + imgIdx;\n\n float prod[numFilters][imgsPerThread];\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * 128 < numImages) {\n #pragma unroll\n for (int f = 0; f < numFilters; f++) {\n prod[f][i] = 0;\n }\n }\n }\n const int loopStartY = MAX(0, startPxY);\n const int loopStartX = MAX(0, startPxX);\n const int loopEndY = MIN(imgSize, startPxY + sizeX);\n const int loopEndX = MIN(imgSize, startPxX + sizeX);\n\n for (int y = loopStartY; y < loopEndY; y++) {\n for (int x = loopStartX; x < loopEndX; x++) {\n const int imgPx = y * imgSize + x;\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * 128 < numImages) {\n #pragma unroll\n for (int f = 0; f < numFilters; f++) {\n prod[f][i] += square(meanDiffs[(f * imgPixels + imgPx) * numImages + i * 128]);\n }\n }\n }\n }\n }\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * 128 < numImages) {\n #pragma unroll\n for (int f = 0; f < numFilters; f++) {\n prod[f][i] = minDiv + addScale * prod[f][i];\n denoms[f * imgPixels * numImages + i * 128] = prod[f][i];\n target[f * imgPixels * numImages + i * 128] = imgs[f * imgPixels * numImages + i * 128] * __powf(prod[f][i], -powScale);\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines filter idx in batches of B_Y*filtersPerThread\n * blockIdx.z determines pixel\n *\n * So each block does one pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * means: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages) (out)\n * target: (numFilters, imgPixels, numImages) (out)\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n * numFilters must be divisible by B_Y*filtersPerThread\n */\ntemplate\n__global__ void kCNorm_manyfilter(float* imgs, float* meanDiffs, float* denoms, float* target, const int imgSize,\n const int numFilters, const int numImages, const int sizeX,\n const float addScale, const float powScale, const float minDiv) {\n const int imgPixels = imgSize * imgSize;\n\n const int pxIdxX = blockIdx.z % imgSize;\n const int pxIdxY = blockIdx.z / imgSize;\n const int blockImgIdx = blockIdx.x * B_X * imgsPerThread;\n const int blockFilterIdx = blockIdx.y * B_Y * filtersPerThread;\n\n const int pxIdx = pxIdxY * imgSize + pxIdxX;\n\n const int startPxX = -sizeX/2 + pxIdxX;\n const int startPxY = -sizeX/2 + pxIdxY;\n const int imgIdx = blockImgIdx + threadIdx.x;\n imgs += ((blockFilterIdx + threadIdx.y) * imgPixels + pxIdx) * numImages + imgIdx;\n meanDiffs += (blockFilterIdx + threadIdx.y) * imgPixels * numImages + imgIdx;\n denoms += ((blockFilterIdx + threadIdx.y) * imgPixels + pxIdx) * numImages + imgIdx;\n target += ((blockFilterIdx + threadIdx.y) * imgPixels + pxIdx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] = 0;\n }\n }\n }\n\n const int loopStartY = max(0, startPxY);\n const int loopStartX = max(0, startPxX);\n const int loopEndY = min(imgSize, startPxY + sizeX);\n const int loopEndX = min(imgSize, startPxX + sizeX);\n\n for (int y = loopStartY; y < loopEndY; y++) {\n for (int x = loopStartX; x < loopEndX; x++) {\n const int imgPx = y * imgSize + x;\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[f][i] += square(meanDiffs[(f * B_Y * imgPixels + imgPx) * numImages + i * B_X]);\n }\n }\n }\n }\n }\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[f][i] = minDiv + addScale * prod[f][i];\n denoms[f * B_Y * imgPixels * numImages + i * B_X] = prod[f][i];\n target[f * B_Y * imgPixels * numImages + i * B_X] = imgs[f * B_Y * imgPixels * numImages + i * B_X] * __powf(prod[f][i], -powScale);\n }\n }\n }\n}\n\n\n/*\n * Block size 16xB_X\n * blockIdx.x determines 4x4 pixel.x region, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines 4x4 pixel.y region, filter idx in batches of filtersPerThread\n *\n * So each block does 4x4 region of pixels for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines pixel idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * means: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages) (out)\n * target: (numFilters, imgPixels, numImages) (out)\n *\n * B_X one of 8, 16, 32\n * imgsPerThread one of 1, 2, 4, 8, 16\n *\n * B_XximgsPerThread MUST be divisible by 32.\n * Number of filters MUST be divisible by filtersPerThread.\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n * numFilters must be divisible by filtersPerThread\n *\n * Final write-out will not be fully coalesced unless B_X is 32. But there's a lot more\n * reading than writing here, and the reading is all coalesced, so it should be OK.\n */\ntemplate\n__global__ void kCNorm2(float* imgs, float* meanDiffs, float* denoms, float* target, const int imgSize,\n const int numFilters, const int numImages, const int sizeX, const float addScale, const float powScale, const float minDiv) {\n __shared__ float shDiffs[filtersPerThread][B_X*imgsPerThread];\n const int imgPixels = imgSize * imgSize;\n const int numImgBlocks = DIVUP(numImages, B_X*imgsPerThread);\n const int numFilterBlocks = numFilters/(filtersPerThread);\n const int blockPxX = 4*(blockIdx.x / numImgBlocks);\n const int blockPxY = 4*(blockIdx.y / numFilterBlocks);\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockFilterIdx = (blockIdx.y % numFilterBlocks) * filtersPerThread;\n\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n const int loadY = tidx / 32, loadX = tidx % 32;\n\n const int startPxX = MAX(0, -sizeX/2 + blockPxX);\n const int startPxY = MAX(0, -sizeX/2 + blockPxY);\n const int endPxX = MIN(imgSize, blockPxX + DIVUP(sizeX, 2) + 3);\n const int endPxY = MIN(imgSize, blockPxY + DIVUP(sizeX, 2) + 3);\n\n const int myPxX = blockPxX + threadIdx.y % 4;\n const int myPxY = blockPxY + threadIdx.y / 4;\n const int myPxIdx = myPxY * imgSize + myPxX;\n// const bool doWork = myPxX < imgSize && myPxY < imgSize;\n const int myStartPxY = -sizeX/2 + myPxY;\n const int myStartPxX = -sizeX/2 + myPxX;\n const int myEndPxY = myPxY + DIVUP(sizeX, 2);\n const int myEndPxX = myPxX + DIVUP(sizeX, 2);\n\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n imgs += (blockFilterIdx * imgPixels + myPxIdx) * numImages + imgIdx;\n meanDiffs += (blockFilterIdx + loadY) * imgPixels * numImages + blockImgIdx + loadX;\n denoms += (blockFilterIdx * imgPixels + myPxIdx) * numImages + imgIdx;\n target += (blockFilterIdx * imgPixels + myPxIdx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] = 0;\n }\n }\n }\n\n for (int y = startPxY; y < endPxY; y++) {\n const bool isInY = y >= myStartPxY && y < myEndPxY;\n for (int x = startPxX; x < endPxX; x++) {\n const int px = y * imgSize + x;\n // All the threads load a pixel from memory\n #pragma unroll\n for (int ly = 0; ly < filtersPerThread; ly += B_X/2) {\n if (filtersPerThread % (B_X/2) == 0 || ly + loadY < filtersPerThread) {\n #pragma unroll\n for (int lx = 0; lx < B_X*imgsPerThread; lx += 32) {\n if (!checkCaseBounds || lx + loadX + blockImgIdx < numImages) {\n shDiffs[ly + loadY][lx + loadX] = meanDiffs[(ly * imgPixels + px) * numImages + lx];\n }\n }\n }\n }\n __syncthreads();\n\n // Each row of threads decides if it's interested in this pixel\n if (isInY && x >= myStartPxX && x < myEndPxX) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] += square(shDiffs[f][threadIdx.x + i * B_X]);\n }\n }\n }\n }\n __syncthreads();\n }\n }\n// imgs -= (loadY * imgPixels - myPxIdx) * numImages + loadX;\n// imgs += threadIdx.x;\n if (myPxX < imgSize && myPxY < imgSize) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] = minDiv + addScale * prod[f][i];\n denoms[f * imgPixels * numImages + i * B_X] = prod[f][i];\n target[f * imgPixels * numImages + i * B_X] = imgs[f * imgPixels * numImages + i * B_X] * __powf(prod[f][i], -powScale);\n }\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, filter idx in batches of B_Y\n *\n * So each block does one pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * meanDiffs: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages) (out)\n * target: (numFilters, imgPixels, numImages) (out)\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n * numFilters must be divisible by B_Y\n */\ntemplate\n__global__ void kFCNorm(cudaTextureObject_t imgs, cudaTextureObject_t meanDiffs, float* target, const int imgSize,\n const int numFilters, const int numImages, const int sizeF,\n const float addScale, const float powScale, const float minDiv) {\n const int imgPixels = imgSize * imgSize;\n const int numImgBlocks = DIVUP(numImages, B_X*imgsPerThread);\n const int numFilterBlocks = numFilters/B_Y;\n const int pxIdxX = blockIdx.x / numImgBlocks;\n const int pxIdxY = blockIdx.y / numFilterBlocks;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int filterIdx = (blockIdx.y % numFilterBlocks) * B_Y + threadIdx.y;\n\n const int pxIdx = pxIdxY * imgSize + pxIdxX;\n\n\n const int imgIdx = blockImgIdx + threadIdx.x;\n const int imgOffset = ((filterIdx) * imgPixels + pxIdx) * numImages + imgIdx;\n const int meanDiffsOffset = pxIdx * numImages + imgIdx;\n// imgs += ((filterIdx) * imgPixels + pxIdx) * numImages + imgIdx;\n// meanDiffs += pxIdx * numImages + imgIdx;\n target += ((filterIdx) * imgPixels + pxIdx) * numImages + imgIdx;\n\n float prod[imgsPerThread];\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[i] = 0;\n }\n }\n\n const int startF = blocked ? (filterIdx / sizeF) * sizeF : -sizeF/2 + filterIdx;\n const int loopStartF = blocked ? startF : MAX(0, startF);\n const int loopEndF = MIN(numFilters, startF + sizeF);\n\n for (int f = loopStartF; f < loopEndF; ++f) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[i] += square(tex1Dfetch(meanDiffs, meanDiffsOffset + f * imgPixels * numImages + i * B_X));\n }\n }\n }\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[i] = minDiv + addScale * prod[i];\n target[i * B_X] = tex1Dfetch(imgs, imgOffset + i * B_X) * __powf(prod[i], -powScale);\n }\n }\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, filter idx in batches of B_Y\n *\n * So each block does one output pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * maxGrads: (numOutputs, imgPixels, numImages)\n * maxActs: (numOutputs, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread\n * numFilters must be divisible by B_Y\n *\n * TODO: this isn't really ideal\n */\ntemplate\n__global__ void kCrossMapMaxPoolUndo(float* imgs, float* maxGrads, float* maxActs, float* target, const int imgSize, const int numFilters,\n const int numImages, const int startF, const int poolSize,\n const int numOutputs, const int stride, const float scaleTargets, const float scaleOutputs) {\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n// const int numOutputs = DIVUP(numFilters, stride);\n const int numFilterBlocks = numFilters/B_Y;\n\n const int pxIdxX = blockIdx.x / numImgBlocks;\n const int pxIdxY = blockIdx.y / numFilterBlocks;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int filterIdx = (blockIdx.y % numFilterBlocks) * B_Y + threadIdx.y;\n\n const int imgPixels = imgSize * imgSize;\n const int pxIdx = pxIdxY * imgSize + pxIdxX;\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n imgs += ((filterIdx) * imgPixels + pxIdx) * numImages + imgIdx;\n maxGrads += (/*(filterIdx) * imgPixels +*/ pxIdx) * numImages + imgIdx;\n maxActs += (/*(filterIdx) * imgPixels +*/ pxIdx) * numImages + imgIdx;\n target += ((filterIdx) * imgPixels + pxIdx) * numImages + imgIdx;\n\n float prod[imgsPerThread];\n// if (imgIdx != 0 || pxIdx != 0 || filterIdx != 0) {\n// return;\n// }\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[i] = 0;\n }\n\n if (filterIdx < numFilters) {\n// const int startOut = max(0, (filterIdx-startF-poolSize)/ stride + 1);\n const int loopStartOut = max(0, (filterIdx-startF-poolSize)/ stride + 1);\n const int loopEndOut = min(numOutputs, (filterIdx - startF)/ stride + 1);\n\n for (int o = loopStartOut; o < loopEndOut; ++o) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n const float ma = maxActs[o * imgPixels * numImages + i * B_X];\n const float mg = maxGrads[o * imgPixels * numImages + i * B_X];\n const float img = imgs[i*B_X];\n prod[i] += (img == ma) * mg;\n }\n }\n }\n // printf(\"gpu f start: %d, end: %d\\n\", loopStartF, loopEndF);\n\n if (!add) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n target[i * B_X] = prod[i];\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n target[i * B_X] = scaleTargets * target[i * B_X] + scaleOutputs * prod[i];\n }\n }\n }\n }\n}\n\n/*\n * images: (numFilters, imgPixels, numImages)\n * maxGrads: (numOutputs, imgPixels, numImages)\n * maxActs: (numOutputs, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n */\nvoid convCrossMapMaxPoolUndo(NVMatrix& images, NVMatrix& maxGrads, NVMatrix& maxActs, NVMatrix& target,\n const int imgSize, const int startF, const int poolSize,\n const int stride, const float scaleTargets, const float scaleOutputs) {\n int numImages = images.getNumCols();\n int imgPixels = imgSize * imgSize;\n int numFilters = images.getNumRows() / imgPixels;\n int numOutputs = maxActs.getNumRows() / imgPixels;\n assert(images.getNumRows() == numFilters * imgPixels);\n assert(maxGrads.getNumRows() == numOutputs * imgPixels);\n assert(maxGrads.getNumCols() == numImages);\n assert(maxGrads.isSameDims(maxActs));\n\n assert(images.getNumRows() == numFilters * imgPixels);\n\n assert(!images.isTrans());\n assert(!target.isTrans());\n assert(!maxGrads.isTrans());\n assert(!maxActs.isTrans());\n assert(images.isContiguous());\n assert(maxGrads.isContiguous());\n assert(maxActs.isContiguous());\n assert(maxGrads.isSameDims(maxActs));\n// assert(numFilters % 16 == 0);\n// assert(numImages % 128 == 0);\n\n assert(stride <= poolSize);\n assert(startF <= 0);\n assert(startF + (numOutputs-1) * stride + poolSize >= numFilters); // All filters must be covered\n\n dim3 threads(32, 4);\n\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n dim3 blocks(imgSize * DIVUP(numImages, threads.x * imgsPerThread), imgSize * DIVUP(numFilters, threads.y));\n bool checkCaseBounds = numImages % (threads.x*imgsPerThread) != 0;\n\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (scaleTargets == 0) {\n target.resize(images);\n if (!checkCaseBounds) {\n if (imgsPerThread == 4) {\n kCrossMapMaxPoolUndo<4, 32, 4, false, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n } else if (imgsPerThread == 2) {\n kCrossMapMaxPoolUndo<4, 32, 2, false, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n } else {\n kCrossMapMaxPoolUndo<4, 32, 1, false, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n }\n } else {\n kCrossMapMaxPoolUndo<4, 32, 1, false, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n }\n } else {\n assert(target.isSameDims(images));\n if (!checkCaseBounds) {\n if (imgsPerThread == 4) {\n kCrossMapMaxPoolUndo<4, 32, 4, true, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n } else if (imgsPerThread == 2) {\n kCrossMapMaxPoolUndo<4, 32, 2, true, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n } else {\n kCrossMapMaxPoolUndo<4, 32, 1, true, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n }\n } else {\n kCrossMapMaxPoolUndo<4, 32, 1, true, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, startF, poolSize, numOutputs, stride,\n scaleTargets, scaleOutputs);\n }\n }\n getLastCudaError(\"convCrossMapMaxPoolUndo: kernel execution failed\");\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, filter idx in batches of B_Y\n *\n * So each block does one output pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * outGrads: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages)\n * inputs: (numFilters, imgPixels, numImages)\n * acts: (numFilters, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread\n * numFilters must be divisible by B_Y\n *\n * TODO: this isn't really ideal\n */\ntemplate\n__global__ void kFRNormUndo(cudaTextureObject_t outGrads, cudaTextureObject_t denoms, cudaTextureObject_t inputs, cudaTextureObject_t acts,\n float* target, const int imgSize, const int numFilters, const int numImages, const int sizeF, const float powScale,\n const float scaleTargets, const float scaleOutputs) {\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int numFilterBlocks = numFilters/B_Y;\n\n const int pxIdxX = blockIdx.x / numImgBlocks;\n const int pxIdxY = blockIdx.y / numFilterBlocks;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int filterIdx = (blockIdx.y % numFilterBlocks) * B_Y + threadIdx.y;\n\n const int imgPixels = imgSize * imgSize;\n const int pxIdx = pxIdxY * imgSize + pxIdxX;\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n const int actsOffset = pxIdx * numImages + imgIdx;\n const int inputOffset = ((filterIdx) * imgPixels + pxIdx) * numImages + imgIdx;\n\n target += inputOffset;\n float prod[imgsPerThread];\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[i] = 0;\n }\n\n const int startF = blocked ? (filterIdx / sizeF) * sizeF : -sizeF + sizeF/2 + 1 + filterIdx;\n const int loopStartF = blocked ? startF : MAX(0, startF);\n const int loopEndF = MIN(numFilters, startF + sizeF);\n\n for (int f = loopStartF; f < loopEndF; ++f) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n prod[i] += tex1Dfetch(acts, actsOffset + f * imgPixels * numImages + i * B_X);\n }\n }\n }\n\n if (!add) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n const float inp = tex1Dfetch(inputs, inputOffset + i * B_X);\n const float out = tex1Dfetch(outGrads, inputOffset + i * B_X);\n const float den = tex1Dfetch(denoms, inputOffset + i * B_X);\n prod[i] = inp * prod[i] + out * __powf(den, -powScale);\n target[i * B_X] = prod[i];\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n const float inp = tex1Dfetch(inputs, inputOffset + i * B_X);\n const float out = tex1Dfetch(outGrads, inputOffset + i * B_X);\n const float den = tex1Dfetch(denoms, inputOffset + i * B_X);\n prod[i] = inp * prod[i] + out * __powf(den, -powScale);\n target[i * B_X] = scaleTargets * target[i * B_X] + scaleOutputs * prod[i];\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, filter idx in batches of B_Y\n *\n * So each block does one output pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * outGrads: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages)\n * inputs: (numFilters, imgPixels, numImages)\n * acts: (numFilters, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread\n * numFilters must be divisible by B_Y\n *\n * TODO: this is pretty wasteful of computation. a lot of threads basically compute the same products.\n */\ntemplate\n//__launch_bounds__(128,16)\n__global__ void kFRNormUndo2(cudaTextureObject_t outGrads, cudaTextureObject_t inputs, cudaTextureObject_t acts, float* target, const int imgSize, const int numFilters,\n const int numImages, const int sizeF, const float addScale, const float powScale, const float minDiv,\n const float scaleTargets, const float scaleOutputs) {\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int numFilterBlocks = numFilters/B_Y;\n\n const int pxIdxX = blockIdx.x / numImgBlocks;\n const int pxIdxY = blockIdx.y / numFilterBlocks;\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int filterIdx = (blockIdx.y % numFilterBlocks) * B_Y + threadIdx.y;\n\n const int imgPixels = imgSize * imgSize;\n const int pxIdx = pxIdxY * imgSize + pxIdxX;\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n const int inpOffset = pxIdx * numImages + imgIdx;\n const int outOffset = ((filterIdx) * imgPixels + pxIdx) * numImages + imgIdx;\n\n target += outOffset;\n\n float prod[imgsPerThread];\n float denoms[imgsPerThread];\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[i] = 0;\n denoms[i] = 0;\n }\n\n int startF = blocked ? (filterIdx / sizeF) * sizeF : -sizeF + sizeF/2 + 1 + filterIdx;\n int loopStartF = blocked ? startF : MAX(0, startF);\n int loopEndF = MIN(numFilters, startF + sizeF);\n\n for (int f = loopStartF; f < loopEndF; ++f) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n // If an input is zero, then we shuldn't divide by it.\n const float grad = tex1Dfetch(outGrads, inpOffset + f * imgPixels * numImages + i * B_X);\n const float act = tex1Dfetch(acts, inpOffset + f * imgPixels * numImages + i * B_X);\n const float inp = tex1Dfetch(inputs, inpOffset + f * imgPixels * numImages + i * B_X) + (act == 0);\n prod[i] += grad * act * __powf(__fdividef(act, inp), 1.0f/powScale);\n }\n }\n }\n\n startF = blocked ? (filterIdx / sizeF) * sizeF : -sizeF/2 + filterIdx;\n loopStartF = blocked ? startF : MAX(0, startF);\n loopEndF = MIN(numFilters, startF + sizeF);\n\n for (int f = loopStartF; f < loopEndF; ++f) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n denoms[i] += square(tex1Dfetch(inputs, inpOffset + f * imgPixels * numImages + i * B_X));\n }\n }\n }\n\n if (!add) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n const float inp = tex1Dfetch(inputs, outOffset + i * B_X);\n const float out = tex1Dfetch(outGrads, outOffset + i * B_X);\n denoms[i] = addScale * denoms[i] + minDiv;\n prod[i] = (-2 * powScale * addScale * inp * prod[i] + out * __powf(denoms[i], -powScale));\n target[i * B_X] = prod[i];\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n const float inp = tex1Dfetch(inputs, outOffset + i * B_X);\n const float out = tex1Dfetch(outGrads, outOffset + i * B_X);\n denoms[i] = addScale * denoms[i] + minDiv;\n prod[i] = (-2 * powScale * addScale * inp * prod[i] + out * __powf(denoms[i], -powScale));\n target[i * B_X] = scaleTargets * target[i * B_X] + scaleOutputs * prod[i];\n }\n }\n }\n}\n\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, filter idx in batches of B_Y*filtersPerThread\n * \n * So each block does one output pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * maxGrads: (numFilters, numOutputs, numImages)\n * rMaxActs: (numFilters, numOutputs, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread\n * numFilters must be divisible by B_Y*filtersPerThread\n */\n\ntemplate\n__global__ void kLocalAvgUndo(float* avgGrads, float* target, const int imgSize, const int numFilters,\n const int numImages, const int subsX, const int startX, const int strideX, const int outputsX,\n const float scaleTargets, const float scaleOutputs) {\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int blockPxX = blockIdx.x / numImgBlocks;\n const int blockPxY = blockIdx.y / (numFilters/(B_Y*filtersPerThread));\n\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockFilterIdx = (blockIdx.y % (numFilters/(B_Y*filtersPerThread))) * B_Y * filtersPerThread;\n\n const int blockPx = blockPxY * imgSize + blockPxX;\n const int numOutputs = outputsX * outputsX;\n const int imgPixels = imgSize * imgSize;\n\n const int startOutputY = blockPxY - startX < subsX ? 0 : 1 + (blockPxY - startX - subsX) / strideX;\n const int endOutputY = MIN(outputsX, 1 + (blockPxY - startX) / strideX);\n const int startOutputX = blockPxX - startX < subsX ? 0 : 1 + (blockPxX - startX - subsX) / strideX;\n const int endOutputX = MIN(outputsX, 1 + (blockPxX - startX) / strideX);\n\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n avgGrads += ((blockFilterIdx + threadIdx.y) * numOutputs) * numImages + imgIdx;\n target += ((blockFilterIdx + threadIdx.y) * imgPixels + blockPx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[f][i] = 0;\n }\n }\n\n if (blockPxX >= startX && blockPxX < startX + strideX * (outputsX-1) + subsX\n && blockPxY >= startX && blockPxY < startX + strideX * (outputsX-1) + subsX) {\n\n for (int my = startOutputY; my < endOutputY; my++) {\n const float regionStartY = fmaxf(0, startX + my * strideX);\n const float regionEndY = fminf(imgSize, startX + my * strideX + subsX);\n const float regionSizeY = regionEndY - regionStartY;\n for (int mx = startOutputX; mx < endOutputX; mx++) {\n const int outputIdx = my * outputsX + mx;\n const float regionStartX = fmaxf(0, startX + mx * strideX);\n const float regionEndX = fminf(imgSize, startX + mx * strideX + subsX);\n const float regionSizeX = regionEndX - regionStartX;\n // It's important to do the division here, because pushing division into the below\n // loops makes the code 4x slower.\n const float regionSizeInv = sum ? 1.0f : (1.0f / (regionSizeX * regionSizeY));\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] += avgGrads[(f * B_Y * numOutputs + outputIdx) * numImages + i * B_X] * regionSizeInv;\n }\n }\n }\n }\n }\n }\n\n if (!add) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n target[f * B_Y * imgPixels * numImages + i * B_X] = prod[f][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n target[f * B_Y * imgPixels * numImages + i * B_X] = scaleTargets * target[f * B_Y * imgPixels * numImages + i * B_X] + scaleOutputs * prod[f][i];\n }\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, filter idx in batches of B_Y*filtersPerThread\n *\n * So each block does one output pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * imgs: (numFilters, imgPixels, numImages)\n * maxGrads: (numFilters, numOutputs, numImages)\n * maxActs: (numFilters, numOutputs, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread\n * numFilters must be divisible by B_Y*filtersPerThread\n */\ntemplate\n__global__ void kLocalMaxUndo(float* imgs, float* maxGrads, float* maxActs, float* target, const int imgSize, const int numFilters,\n const int numImages, const int subsX, const int startX, const int strideX, const int outputsX,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImgs[B_Y*filtersPerThread][B_X*imgsPerThread];\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int blockPxX = blockIdx.x / numImgBlocks;\n const int blockPxY = blockIdx.y / (numFilters/(B_Y*filtersPerThread));\n\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockFilterIdx = (blockIdx.y % (numFilters/(B_Y*filtersPerThread))) * B_Y * filtersPerThread;\n\n const int blockPx = blockPxY * imgSize + blockPxX;\n const int numOutputs = outputsX * outputsX;\n const int imgPixels = imgSize * imgSize;\n\n const int startOutputY = blockPxY - startX < subsX ? 0 : 1 + (blockPxY - startX - subsX) / strideX;\n const int endOutputY = MIN(outputsX, 1 + (blockPxY - startX) / strideX);\n const int startOutputX = blockPxX - startX < subsX ? 0 : 1 + (blockPxX - startX - subsX) / strideX;\n const int endOutputX = MIN(outputsX, 1 + (blockPxX - startX) / strideX);\n\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n imgs += ((blockFilterIdx + threadIdx.y) * imgPixels + blockPx) * numImages + imgIdx;\n maxGrads += ((blockFilterIdx + threadIdx.y) * numOutputs) * numImages\n + imgIdx;\n maxActs += ((blockFilterIdx + threadIdx.y) * numOutputs) * numImages\n + imgIdx;\n\n target += ((blockFilterIdx + threadIdx.y) * imgPixels + blockPx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[f][i] = 0;\n }\n }\n\n if (blockPxX >= startX && blockPxX < startX + strideX * (outputsX-1) + subsX\n && blockPxY >= startX && blockPxY < startX + strideX * (outputsX-1) + subsX) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n shImgs[threadIdx.y + B_Y * f][threadIdx.x + B_X * i] = imgs[f * B_Y * imgPixels * numImages + i * B_X];\n }\n }\n }\n for (int my = startOutputY; my < endOutputY; my++) {\n for (int mx = startOutputX; mx < endOutputX; mx++) {\n const int outputIdx = my * outputsX + mx;\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n const float ma = maxActs[(f * B_Y * numOutputs + outputIdx) * numImages + i * B_X];\n const float mg = maxGrads[(f * B_Y * numOutputs + outputIdx) * numImages + i * B_X];\n const float img = shImgs[threadIdx.y + B_Y * f][threadIdx.x + B_X * i];\n\n prod[f][i] += (img == ma) * mg;\n }\n }\n }\n }\n }\n }\n if (!add) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n target[f * B_Y * imgPixels * numImages + i * B_X] = prod[f][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n target[f * B_Y * imgPixels * numImages + i * B_X] = scaleTargets * target[f * B_Y * imgPixels * numImages + i * B_X] + scaleOutputs * prod[f][i];\n }\n }\n }\n }\n}\n\n/*\n * acts := -2 x scale x acts x outGrads / denoms\n */\ntemplate\n__global__ void kRNormUndoPrelims(float* acts, cudaTextureObject_t denoms, cudaTextureObject_t outGrads,\n const uint numElements, const float scale) {\n const uint e = B_X * blockIdx.x * eltsPerThread + threadIdx.x;\n const uint numThreads = B_X * gridDim.x;\n for (uint i = e; i < numElements; i += numThreads*eltsPerThread) {\n #pragma unroll\n for (uint k = 0; k < eltsPerThread; k++) {\n if (i + k * B_X < numElements) {\n acts[i + k * B_X] = __fdividef(scale * tex1Dfetch(outGrads, i + k * B_X) * acts[i + k * B_X],\n tex1Dfetch(denoms, i + k * B_X));\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X\n * blockIdx.x determines pixel.x, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines pixel.y, filter idx in batches of B_Y*filtersPerThread\n *\n * So each block does one output pixel for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines filter idx\n *\n * outGrads: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages)\n * inputs: (numFilters, imgPixels, numImages)\n * acts: (numFilters, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * numImages must be divisible by B_X*imgsPerThread\n * numFilters must be divisible by B_Y*filtersPerThread\n *\n * TODO: this isn't really ideal\n */\ntemplate\n__global__ void kRNormUndo(float* outGrads, float* denoms, float* inputs, float* acts, float* target, const int imgSize, const int numFilters,\n const int numImages, const int sizeX, const float powScale, const float scaleTargets, const float scaleOutputs) {\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int numFilterBlocks = numFilters/(B_Y*filtersPerThread);\n\n const int blockPxX = blockIdx.x / numImgBlocks;\n const int blockPxY = blockIdx.y / numFilterBlocks;\n\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockFilterIdx = (blockIdx.y % numFilterBlocks) * B_Y * filtersPerThread;\n\n const int blockPx = blockPxY * imgSize + blockPxX;\n const int imgPixels = imgSize * imgSize;\n\n const int startY = MAX(0, blockPxY + sizeX/2 - sizeX + 1);\n const int startX = MAX(0, blockPxX + sizeX/2 - sizeX + 1);\n const int endY = MIN(imgSize, blockPxY + sizeX/2 + 1);\n const int endX = MIN(imgSize, blockPxX + sizeX/2 + 1);\n\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n acts += ((blockFilterIdx + threadIdx.y) * imgPixels) * numImages + imgIdx;\n inputs += ((blockFilterIdx + threadIdx.y) * imgPixels + blockPx) * numImages + imgIdx;\n denoms += ((blockFilterIdx + threadIdx.y) * imgPixels + blockPx) * numImages + imgIdx;\n outGrads += ((blockFilterIdx + threadIdx.y) * imgPixels + blockPx) * numImages + imgIdx;\n target += ((blockFilterIdx + threadIdx.y) * imgPixels + blockPx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[f][i] = 0;\n }\n }\n\n for (int sy = startY; sy < endY; sy++) {\n for (int sx = startX; sx < endX; sx++) {\n const int outPx = sy * imgSize + sx;\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] += acts[(f * B_Y * imgPixels + outPx) * numImages + i * B_X];\n }\n }\n }\n }\n }\n// outGrads += blockPx * numImages;\n if (scaleTargets == 0) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n const float inp = inputs[(f * B_Y * imgPixels) * numImages + i * B_X];\n const float out = outGrads[(f * B_Y * imgPixels) * numImages + i * B_X];\n const float den = denoms[(f * B_Y * imgPixels) * numImages + i * B_X];\n prod[f][i] = inp * prod[f][i] + out * __powf(den, -powScale);\n target[f * B_Y * imgPixels * numImages + i * B_X] = prod[f][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n const float inp = inputs[(f * B_Y * imgPixels) * numImages + i * B_X];\n const float out = outGrads[(f * B_Y * imgPixels) * numImages + i * B_X];\n const float den = denoms[(f * B_Y * imgPixels) * numImages + i * B_X];\n prod[f][i] = inp * prod[f][i] + out * __powf(den, -powScale);\n target[f * B_Y * imgPixels * numImages + i * B_X] =\n scaleTargets * target[f * B_Y * imgPixels * numImages + i * B_X]\n + scaleOutputs * prod[f][i];\n }\n }\n }\n }\n}\n\n/*\n * Block size 16xB_X\n * blockIdx.x determines 4x4 pixel.x region, image idx in batches of B_X*imgsPerThread\n * blockIdx.y determines 4x4 pixel.y region, filter idx in batches of filtersPerThread\n *\n * So each block does 4x4 region for some number of images/filters.\n *\n * threadIdx.x determines img idx\n * threadIdx.y determines pixel idx\n *\n * outGrads: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages)\n * inputs: (numFilters, imgPixels, numImages)\n * acts: (numFilters, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * B_X one of 8, 16, 32\n * imgsPerThread one of 1, 2, 4, 8, 16\n *\n * B_XximgsPerThread MUST be divisible by 32.\n * Number of filters MUST be divisible by filtersPerThread.\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false\n * numFilters must be divisible by filtersPerThread\n *\n * Final write-out will not be fully coalesced unless B_X is 32. But there's a lot more\n * reading than writing here, and the reading is all coalesced, so it should be OK.\n */\ntemplate\n__global__ void kRNormUndo2(float* outGrads, float* denoms, float* inputs, float* acts, float* target, const int imgSize, const int numFilters,\n const int numImages, const int sizeX, const float powScale, const float scaleTargets, const float scaleOutputs) {\n __shared__ float shActs[filtersPerThread][B_X*imgsPerThread];\n const int imgPixels = imgSize * imgSize;\n const int numImgBlocks = DIVUP(numImages, B_X*imgsPerThread);\n const int numFilterBlocks = numFilters/(filtersPerThread);\n const int blockPxX = 4*(blockIdx.x / numImgBlocks);\n const int blockPxY = 4*(blockIdx.y / numFilterBlocks);\n const int blockImgIdx = (blockIdx.x % numImgBlocks) * B_X * imgsPerThread;\n const int blockFilterIdx = (blockIdx.y % numFilterBlocks) * filtersPerThread;\n\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n const int loadY = tidx / 32, loadX = tidx % 32;\n\n const int startPxX = MAX(0, -DIVUP(sizeX,2) + blockPxX + 1);\n const int startPxY = MAX(0, -DIVUP(sizeX,2) + blockPxY + 1);\n const int endPxX = MIN(imgSize, blockPxX + sizeX/2 + 4);\n const int endPxY = MIN(imgSize, blockPxY + sizeX/2 + 4);\n\n const int myPxX = blockPxX + threadIdx.y % 4;\n const int myPxY = blockPxY + threadIdx.y / 4;\n const int myPxIdx = myPxY * imgSize + myPxX;\n// const bool doWork = myPxX < imgSize && myPxY < imgSize;\n const int myStartPxY = -DIVUP(sizeX,2) + myPxY + 1;\n const int myStartPxX = -DIVUP(sizeX,2) + myPxX + 1;\n const int myEndPxY = myPxY + sizeX/2 + 1;\n const int myEndPxX = myPxX + sizeX/2 + 1;\n\n const int imgIdx = blockImgIdx + threadIdx.x;\n\n acts += (blockFilterIdx + loadY) * imgPixels * numImages + blockImgIdx + loadX;\n denoms += (blockFilterIdx * imgPixels + myPxIdx) * numImages + imgIdx;\n inputs += (blockFilterIdx * imgPixels + myPxIdx) * numImages + imgIdx;\n outGrads += (blockFilterIdx * imgPixels + myPxIdx) * numImages + imgIdx;\n target += (blockFilterIdx * imgPixels + myPxIdx) * numImages + imgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[f][i] = 0;\n }\n }\n\n for (int y = startPxY; y < endPxY; y++) {\n const bool isInY = y >= myStartPxY && y < myEndPxY;\n for (int x = startPxX; x < endPxX; x++) {\n const int px = y * imgSize + x;\n // All the threads load a pixel from memory\n #pragma unroll\n for (int ly = 0; ly < filtersPerThread; ly += B_X/2) {\n if (filtersPerThread % (B_X/2) == 0 || ly + loadY < filtersPerThread) {\n #pragma unroll\n for (int lx = 0; lx < B_X*imgsPerThread; lx += 32) {\n if (!checkCaseBounds || lx + loadX + blockImgIdx < numImages) {\n shActs[ly + loadY][lx + loadX] = acts[(ly * imgPixels + px) * numImages + lx];\n }\n }\n }\n }\n __syncthreads();\n\n // Each row of threads decides if it's interested in this pixel\n if (isInY && x >= myStartPxX && x < myEndPxX) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[f][i] += shActs[f][threadIdx.x + i * B_X];\n }\n }\n }\n }\n __syncthreads();\n }\n }\n acts -= (loadY * imgPixels - myPxIdx) * numImages + loadX;\n acts += threadIdx.x;\n if (myPxX < imgSize && myPxY < imgSize) {\n if (!add) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n const float out = outGrads[f * imgPixels * numImages + i * B_X];\n const float den = denoms[f * imgPixels * numImages + i * B_X];\n const float inp = inputs[f * imgPixels * numImages + i * B_X];\n prod[f][i] = inp * prod[f][i] + out * __powf(den, -powScale);\n target[f * imgPixels * numImages + i * B_X] = prod[f][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || imgIdx + i * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n const float out = outGrads[f * imgPixels * numImages + i * B_X];\n const float den = denoms[f * imgPixels * numImages + i * B_X];\n const float inp = inputs[f * imgPixels * numImages + i * B_X];\n prod[f][i] = inp * prod[f][i] + out * __powf(den, -powScale);\n target[f * imgPixels * numImages + i * B_X] = scaleTargets * target[f * imgPixels * numImages + i * B_X] + scaleOutputs * prod[f][i];\n }\n }\n }\n }\n\n }\n}\n\nvoid convLocalMaxUndo(NVMatrix& images, NVMatrix& maxGrads, NVMatrix& maxActs, NVMatrix& target,\n int subsX, int startX, int strideX, int outputsX) {\n convLocalMaxUndo(images, maxGrads, maxActs, target, subsX, startX, strideX, outputsX, 0, 1);\n}\n\n/*\n * imgs: (numFilters, imgPixels, numImages)\n * maxGrads: (numFilters, numOutputs, numImages)\n * rMaxActs: (numFilters, numOutputs, numImages)\n * target: (numFilters, imgPixels, numImages)\n */\nvoid convLocalMaxUndo(NVMatrix& images, NVMatrix& maxGrads, NVMatrix& maxActs, NVMatrix& target,\n int subsX, int startX, int strideX, int outputsX, float scaleTargets, float scaleOutput) {\n int outputs = outputsX * outputsX;\n int numImages = images.getNumCols();\n int numFilters = maxGrads.getNumRows() / outputs;\n int imgPixels = images.getNumRows() / numFilters;\n assert(images.getNumRows() == numFilters * imgPixels);\n int imgSize = int(sqrt(imgPixels));\n\n assert(imgSize * imgSize == imgPixels);\n assert(maxGrads.getNumRows() == numFilters * outputs);\n assert(maxGrads.getNumCols() == numImages);\n assert(!images.isTrans());\n assert(!target.isTrans());\n assert(!maxGrads.isTrans());\n assert(!maxActs.isTrans());\n assert(images.isContiguous());\n assert(maxGrads.isContiguous());\n assert(maxActs.isContiguous());\n assert(maxGrads.isSameDims(maxActs));\n assert(numFilters % 16 == 0);\n// assert(numImages % 128 == 0);\n\n assert(strideX <= subsX);\n\n target.resize(images);\n assert(target.isContiguous());\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n int checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages,32*imgsPerThread) * imgSize, (numFilters / (4 * 2)) * imgSize);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalMaxUndo<4, 32, 4, 2, false, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalMaxUndo<4, 32, 4, 2, true, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalMaxUndo<4, 32, 4, 2, false, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalMaxUndo<4, 32, 4, 2, true, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n } else if (imgsPerThread == 2) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalMaxUndo<4, 32, 2, 2, false, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalMaxUndo<4, 32, 2, 2, true, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalMaxUndo<4, 32, 2, 2, false, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalMaxUndo<4, 32, 2, 2, true, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n } else {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalMaxUndo<4, 32, 1, 2, false, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalMaxUndo<4, 32, 1, 2, true, true><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalMaxUndo<4, 32, 1, 2, false, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalMaxUndo<4, 32, 1, 2, true, false><<>>(images.getDevData(), maxGrads.getDevData(), maxActs.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n }\n\n getLastCudaError(\"convLocalMaxUndo: kernel execution failed\");\n}\n\nvoid convLocalAvgUndo(NVMatrix& avgGrads, NVMatrix& target, int subsX, int startX, int strideX, int outputsX, int imgSize, bool sum) {\n convLocalAvgUndo(avgGrads, target, subsX, startX, strideX, outputsX, imgSize, sum, 0, 1);\n}\n\n/*\n * avgGrads: (numFilters, numOutputs, numImages)\n * target: (numFilters, imgPixels, numImages)\n */\nvoid convLocalAvgUndo(NVMatrix& avgGrads, NVMatrix& target,\n int subsX, int startX, int strideX, int outputsX, int imgSize, bool sum,\n float scaleTargets, float scaleOutput) {\n int numImages = avgGrads.getNumCols();\n\n int outputs = outputsX * outputsX;\n int imgPixels = imgSize * imgSize;\n int numFilters = avgGrads.getNumRows() / outputs;\n assert(avgGrads.getNumRows() == numFilters * outputs);\n\n assert(!target.isTrans());\n assert(!avgGrads.isTrans());\n assert(avgGrads.isContiguous());\n assert(numFilters % 16 == 0);\n// assert(numImages % 128 == 0);\n\n assert(strideX <= subsX);\n\n target.resize(numFilters * imgPixels, numImages);\n assert(target.isContiguous());\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n int checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages,32*imgsPerThread) * imgSize, (numFilters / (4 * 4)) * imgSize);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n bool scale = !(scaleTargets == 0 && scaleOutput == 1);\n if (sum) {\n if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 4, 4, true, false, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 4, 4, true, true, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 4, 4, true, false, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 4, 4, true, true, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n } else if (imgsPerThread == 2) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 2, 4, true, false, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 2, 4, true, true, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 2, 4, true, false, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 2, 4, true, true, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n } else {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 1, 4, true, false, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 1, 4, true, true, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 1, 4, true, false, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 1, 4, true, true, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n }\n } else {\n if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 4, 4, false, false, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 4, 4, false, true, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 4, 4, false, false, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 4, 4, false, true, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n } else if (imgsPerThread == 2) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 2, 4, false, false, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 2, 4, false, true, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 2, 4, false, false, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 2, 4, false, true, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n } else {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 1, 4, false, false, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 1, 4, false, true, true> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n kLocalAvgUndo<4, 32, 1, 4, false, false, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n } else {\n kLocalAvgUndo<4, 32, 1, 4, false, true, false> <<>>(avgGrads.getDevData(), target.getDevData(), imgSize,\n numFilters, numImages, subsX, startX, strideX, outputsX, scaleTargets, scaleOutput);\n }\n }\n }\n }\n\n getLastCudaError(\"convLocalAvgUndo: kernel execution failed\");\n}\n\nvoid convResponseNorm(NVMatrix& images, NVMatrix& denoms, NVMatrix& target, int numFilters, int sizeX, float addScale, float powScale, float minDiv) {\n convContrastNorm(images, images, denoms, target, numFilters, sizeX, addScale, powScale, minDiv);\n}\n\n/*\n * images: (numFilters, imgPixels, numImages)\n * meanDiffs: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages) (out)\n * target: (numFilters, imgPixels, numImages) (out)\n */\nvoid convContrastNorm(NVMatrix& images, NVMatrix& meanDiffs, NVMatrix& denoms, NVMatrix& target, int numFilters, int sizeX, float addScale, float powScale, float minDiv) {\n int numImages = images.getNumCols();\n int imgPixels = images.getNumRows() / numFilters;\n assert(images.getNumRows() == numFilters * imgPixels);\n int imgSize = int(sqrt(imgPixels));\n assert(imgSize * imgSize == imgPixels);\n assert(meanDiffs.isSameDims(images));\n\n assert(!meanDiffs.isTrans());\n assert(!images.isTrans());\n assert(images.isContiguous());\n assert(meanDiffs.isContiguous());\n assert(numFilters % 16 == 0 || numFilters <= 8);\n\n target.resize(images);\n denoms.resize(images);\n assert(target.isContiguous());\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (sizeX >= 6 && numFilters % 4 == 0) {\n // This one is faster for large regions (my tests show regions >= 6...)\n int imgsPerThread = 8;\n int filtersPerThread = 4;\n int bx = 8;\n bool checkCaseBounds = numImages % (bx*imgsPerThread) != 0;\n assert((imgsPerThread * bx) % 32 == 0);\n assert(numFilters % filtersPerThread == 0);\n dim3 threads(bx, 16);\n dim3 blocks(DIVUP(imgSize, 4) * DIVUP(numImages, bx*imgsPerThread), DIVUP(imgSize, 4) * numFilters / filtersPerThread);\n\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm2<8, 8, 4, true>, cudaFuncCachePreferL1); // L1 faster here\n kCNorm2<8, 8, 4, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm2<8, 8, 4, false>, cudaFuncCachePreferL1); // L1 faster here\n kCNorm2<8, 8, 4, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else {\n bool checkCaseBounds = numImages % 128 != 0;\n if (numFilters <= 8) {\n dim3 threads(128);\n dim3 blocks(DIVUP(numImages,128) * imgSize, imgSize);\n if (numFilters == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 1, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 1, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 1, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 1, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else if (numFilters == 2) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 2, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 2, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 2, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 2, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else if (numFilters == 3) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 3, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 3, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 3, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 3, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else if (numFilters == 4) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 4, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 4, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 4, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 4, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else if (numFilters == 5) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 5, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 5, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 5, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 5, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else if (numFilters == 6) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 6, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 6, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 6, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 6, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else if (numFilters == 7) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 7, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 7, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 7, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 7, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n } else if (numFilters == 8) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 8, true>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 8, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_fewfilter<1, 8, false>, cudaFuncCachePreferL1);\n kCNorm_fewfilter<1, 8, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numImages, sizeX, addScale, powScale, minDiv);\n }\n }\n } else {\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages,threads.x*4), (numFilters / (threads.y * 2)), imgPixels);\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kCNorm_manyfilter<4, 32, 4, 2, true>, cudaFuncCachePreferL1);\n kCNorm_manyfilter<4, 32, 4, 2, true><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, sizeX, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kCNorm_manyfilter<4, 32, 4, 2, false>, cudaFuncCachePreferL1);\n kCNorm_manyfilter<4, 32, 4, 2, false><<>>(images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(),\n imgSize, numFilters, numImages, sizeX, addScale, powScale, minDiv);\n }\n }\n }\n getLastCudaError(\"convResponseNorm: kernel execution failed\");\n}\n\nvoid convContrastNormUndo(NVMatrix& outGrads, NVMatrix& denoms, NVMatrix& meanDiffs, NVMatrix& acts, NVMatrix& target, int numFilters,\n int sizeX, float addScale, float powScale, float scaleTargets, float scaleOutput) {\n convResponseNormUndo(outGrads, denoms, meanDiffs, acts, target, numFilters, sizeX, addScale, powScale, scaleTargets, scaleOutput);\n}\n\n/*\n * outGrads: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages)\n * inputs: (numFilters, imgPixels, numImages)\n * acts: (numFilters, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * THIS WILL OVERWRITE THE ACTS MATRIX.\n */\nvoid convResponseNormUndo(NVMatrix& outGrads, NVMatrix& denoms, NVMatrix& inputs, NVMatrix& acts, NVMatrix& target, int numFilters,\n int sizeX, float addScale, float powScale, float scaleTargets, float scaleOutput) {\n int numImages = outGrads.getNumCols();\n int imgPixels = outGrads.getNumRows() / numFilters;\n\n int imgSize = int(sqrt(imgPixels));\n assert(imgSize * imgSize == imgPixels);\n\n assert(outGrads.getNumRows() == numFilters * imgPixels);\n\n assert(denoms.isSameDims(outGrads));\n assert(acts.isSameDims(denoms));\n assert(!denoms.isTrans());\n assert(!outGrads.isTrans());\n assert(!acts.isTrans());\n assert(!target.isTrans());\n assert(outGrads.isContiguous());\n\n assert(numFilters % 16 == 0);\n\n target.resize(outGrads);\n assert(target.isContiguous());\n // First do acts := -2 x scale x acts x outGrads / denoms\n // so that the main routine only has to do an addition in its inner loop.\n int prelimEltsPerThread = 8;\n dim3 threads(128);\n dim3 blocks(DIVUP(outGrads.getNumElements(),(threads.x * prelimEltsPerThread)));\n bool checkPrelimBounds = outGrads.getNumElements() % (threads.x * prelimEltsPerThread) != 0;\n //printf(\"num elts: %d, blocks: %d\\n\", outGrads.getNumElements(), blocks.x);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n kRNormUndoPrelims<128, 8><<>>(acts.getDevData(), denoms.getTextureObject(), outGrads.getTextureObject(), outGrads.getNumElements(), -2*addScale*powScale);\n\n // Now the main routine\n if (sizeX >= 6 && numFilters % 4 == 0) {\n // This one is faster for large regions (my tests show regions >= 6...)\n // NOTE: this stuff is not optimized for Kepler. Only kRNormUndo is.\n int imgsPerThread = numImages % 128 == 0 ? 8 : numImages % 64 == 0 ? 4 : 2;\n int filtersPerThread = 4;\n int bx = 16;\n bool checkCaseBounds = numImages % (bx*imgsPerThread) != 0;\n assert((imgsPerThread * bx) % 32 == 0);\n\n threads = dim3(bx, 16);\n blocks = dim3(DIVUP(imgSize, 4) * DIVUP(numImages, bx*imgsPerThread), DIVUP(imgSize, 4) * numFilters / filtersPerThread);\n if (imgsPerThread == 8) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 8, 4, true, true>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 8, 4, true, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 8, 4, false, true>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 8, 4, false, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 8, 4, true, false>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 8, 4, true, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 8, 4, false, false>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 8, 4, false, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n }\n } else if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 4, 4, true, true>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 4, 4, true, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 4, 4, false, true>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 4, 4, false, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 4, 4, true, false>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 4, 4, true, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 4, 4, false, false>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 4, 4, false, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n }\n } else {\n if (checkCaseBounds) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 2, 4, true, true>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 2, 4, true, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 2, 4, false, true>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 2, 4, false, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 2, 4, true, false>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 2, 4, true, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo2<16, 2, 4, false, false>, cudaFuncCachePreferL1);\n kRNormUndo2<16, 2, 4, false, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n }\n }\n } else {\n int imgsPerThread = numImages % 128 == 0 ? 4 : 1;\n bool checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n threads = dim3(32, 4);\n blocks = dim3(DIVUP(numImages,32*imgsPerThread) * imgSize, (numFilters / (4 * 2)) * imgSize);\n\n if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRNormUndo<4, 32, 4, 2, true>, cudaFuncCachePreferL1);\n kRNormUndo<4, 32, 4, 2, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo<4, 32, 4, 2, false>, cudaFuncCachePreferL1);\n kRNormUndo<4, 32, 4, 2, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRNormUndo<4, 32, 1, 2, true>, cudaFuncCachePreferL1);\n kRNormUndo<4, 32, 1, 2, true><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kRNormUndo<4, 32, 1, 2, false>, cudaFuncCachePreferL1);\n kRNormUndo<4, 32, 1, 2, false><<>>(outGrads.getDevData(), denoms.getDevData(), inputs.getDevData(), acts.getDevData(),\n target.getDevData(), imgSize, numFilters, numImages, sizeX, powScale,\n scaleTargets, scaleOutput);\n }\n }\n }\n getLastCudaError(\"kRNormUndo: kernel execution failed\");\n}\n\n/*\n * imgs: (numChannels, imgPixels, numImages) with given imgStride\n * target: (numChannels, tgtPixels, numImages)\n *\n * imgSize = scale * tgtSize\n */\nvoid convResizeBilinear(NVMatrix& images, NVMatrix& target, int imgSize, int tgtSize, float scale) {\n assert(!images.isTrans());\n assert(!target.isTrans());\n int imgPixels = imgSize * imgSize;\n int tgtPixels = tgtSize * tgtSize;\n int numChannels = images.getNumRows() / imgPixels;\n int numImages = images.getNumCols();\n assert(images.getNumRows() == numChannels * imgPixels);\n\n target.resize(numChannels * tgtPixels, numImages);\n assert(target.isContiguous());\n int numChunksX = DIVUP(tgtSize, 4);\n int numChunks = numChunksX * numChunksX;\n double imgCenter = imgSize * 0.5;\n double tgtCenter = tgtSize * 0.5;\n double centerScale = imgCenter - tgtCenter * scale;\n\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n bool checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n cudaStream_t stream = NVMatrix::getDefaultStream();\n dim3 threads(32, 16);\n dim3 blocks(DIVUP(numImages, imgsPerThread * 32), numChannels * numChunks);\n if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kResizeBilinear<4, true>, cudaFuncCachePreferL1);\n kResizeBilinear<4, true><<>>(images.getDevData(), target.getDevData(), imgSize, tgtSize, numImages, images.getStride(), scale, centerScale);\n } else {\n cudaFuncSetCacheConfig(kResizeBilinear<4, false>, cudaFuncCachePreferL1);\n kResizeBilinear<4, false><<>>(images.getDevData(), target.getDevData(), imgSize, tgtSize, numImages, images.getStride(), scale, centerScale);\n }\n } else if (imgsPerThread == 2) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kResizeBilinear<2, true>, cudaFuncCachePreferL1);\n kResizeBilinear<2, true><<>>(images.getDevData(), target.getDevData(), imgSize, tgtSize, numImages, images.getStride(), scale, centerScale);\n } else {\n cudaFuncSetCacheConfig(kResizeBilinear<2, false>, cudaFuncCachePreferL1);\n kResizeBilinear<2, false><<>>(images.getDevData(), target.getDevData(), imgSize, tgtSize, numImages, images.getStride(), scale, centerScale);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kResizeBilinear<1, true>, cudaFuncCachePreferL1);\n kResizeBilinear<1, true><<>>(images.getDevData(), target.getDevData(), imgSize, tgtSize, numImages, images.getStride(), scale, centerScale);\n } else {\n cudaFuncSetCacheConfig(kResizeBilinear<1, false>, cudaFuncCachePreferL1);\n kResizeBilinear<1, false><<>>(images.getDevData(), target.getDevData(), imgSize, tgtSize, numImages, images.getStride(), scale, centerScale);\n }\n }\n getLastCudaError(\"convResizeBilinear: kernel execution failed\");\n}\n\n/*\n * imgs: (3, imgPixels, numImages) with given imgStride\n * target: (3, imgPixels, numImages)\n */\nvoid convRGBToYUV(NVMatrix& images, NVMatrix& target) {\n assert(!images.isTrans());\n assert(!target.isTrans());\n int imgPixels = images.getNumRows() / 3;\n int numImages = images.getNumCols();\n assert(images.getNumRows() == 3 * imgPixels);\n\n target.resize(3 * imgPixels, numImages);\n assert(target.isContiguous());\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n bool checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n cudaStream_t stream = NVMatrix::getDefaultStream();\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages, imgsPerThread * 32), DIVUP(imgPixels, 4));\n if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToYUV<4, true>, cudaFuncCachePreferL1);\n kRGBToYUV<4, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToYUV<4, false>, cudaFuncCachePreferL1);\n kRGBToYUV<4, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n } else if (imgsPerThread == 2) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToYUV<2, true>, cudaFuncCachePreferL1);\n kRGBToYUV<2, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToYUV<2, false>, cudaFuncCachePreferL1);\n kRGBToYUV<2, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToYUV<1, true>, cudaFuncCachePreferL1);\n kRGBToYUV<1, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToYUV<1, false>, cudaFuncCachePreferL1);\n kRGBToYUV<1, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n }\n getLastCudaError(\"convRGBToYUV: kernel execution failed\");\n}\n\n/*\n * imgs: (3, imgPixels, numImages) with given imgStride\n * target: (3, imgPixels, numImages)\n */\nvoid convRGBToLAB(NVMatrix& images, NVMatrix& target, bool center) {\n assert(!images.isTrans());\n assert(!target.isTrans());\n int imgPixels = images.getNumRows() / 3;\n int numImages = images.getNumCols();\n assert(images.getNumRows() == 3 * imgPixels);\n\n target.resize(3 * imgPixels, numImages);\n assert(target.isContiguous());\n\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n bool checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages, imgsPerThread * 32), DIVUP(imgPixels, 4));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (imgsPerThread == 4) {\n if (center) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToLAB<4, true, true>, cudaFuncCachePreferL1);\n kRGBToLAB<4, true, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToLAB<4, false, true>, cudaFuncCachePreferL1);\n kRGBToLAB<4, false, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToLAB<4, true, false>, cudaFuncCachePreferL1);\n kRGBToLAB<4, true, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToLAB<4, false, false>, cudaFuncCachePreferL1);\n kRGBToLAB<4, false, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n }\n } else if (imgsPerThread == 2) {\n if (center) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToLAB<2, true, true>, cudaFuncCachePreferL1);\n kRGBToLAB<2, true, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToLAB<2, false, true>, cudaFuncCachePreferL1);\n kRGBToLAB<2, false, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToLAB<2, true, false>, cudaFuncCachePreferL1);\n kRGBToLAB<2, true, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToLAB<2, false, false>, cudaFuncCachePreferL1);\n kRGBToLAB<2, false, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n }\n } else {\n if (center) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToLAB<1, true, true>, cudaFuncCachePreferL1);\n kRGBToLAB<1, true, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToLAB<1, false, true>, cudaFuncCachePreferL1);\n kRGBToLAB<1, false, true><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kRGBToLAB<1, true, false>, cudaFuncCachePreferL1);\n kRGBToLAB<1, true, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n } else {\n cudaFuncSetCacheConfig(kRGBToLAB<1, false, false>, cudaFuncCachePreferL1);\n kRGBToLAB<1, false, false><<>>(images.getDevData(), target.getDevData(), imgPixels, numImages, images.getStride());\n }\n }\n }\n getLastCudaError(\"convRGBToLAB: kernel execution failed\");\n}\n\n/*\n * imgs: (numChannels, imgPixels, numImages) with given imgStride\n * target: (numChannels, tgtPixels, numImages)\n */\nvoid convCrop(NVMatrix& imgs, NVMatrix& target, int imgSize, int tgtSize, int startY, int startX) {\n int numImages = imgs.getNumCols();\n int imgPixels = imgSize * imgSize;\n int tgtPixels = tgtSize * tgtSize;\n\n int numChannels = imgs.getNumRows() / imgPixels;\n assert(imgs.getNumRows() == imgPixels * numChannels);\n assert(imgPixels == imgSize * imgSize);\n assert(imgSize - startY >= tgtSize);\n assert(imgSize - startX >= tgtSize);\n assert(startY >= 0);\n assert(startX >= 0);\n target.resize(numChannels * tgtPixels, numImages);\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n bool checkCaseBounds = numImages % (32*imgsPerThread) != 0;\n dim3 blocks(DIVUP(numImages, 32 * imgsPerThread), numChannels * DIVUP(tgtPixels, 4));\n dim3 threads(32, 4);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (imgsPerThread == 4) {\n if (checkCaseBounds) {\n kCrop<4, true><<>>(imgs.getDevData(), target.getDevData(), numImages, imgs.getStride(), imgSize, tgtSize, startY, startX);\n } else {\n kCrop<4, false><<>>(imgs.getDevData(), target.getDevData(), numImages, imgs.getStride(), imgSize, tgtSize, startY, startX);\n }\n } else if (imgsPerThread == 2) {\n if (checkCaseBounds) {\n kCrop<2, true><<>>(imgs.getDevData(), target.getDevData(), numImages, imgs.getStride(), imgSize, tgtSize, startY, startX);\n } else {\n kCrop<2, false><<>>(imgs.getDevData(), target.getDevData(), numImages, imgs.getStride(), imgSize, tgtSize, startY, startX);\n }\n } else {\n if (checkCaseBounds) {\n kCrop<1, true><<>>(imgs.getDevData(), target.getDevData(), numImages, imgs.getStride(), imgSize, tgtSize, startY, startX);\n } else {\n kCrop<1, false><<>>(imgs.getDevData(), target.getDevData(), numImages, imgs.getStride(), imgSize, tgtSize, startY, startX);\n }\n }\n getLastCudaError(\"convCrop: kernel execution failed\");\n}\n\n/*\n * images: (numFilters, imgPixels, numImages)\n * meanDiffs: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages) (out)\n * target: (numFilters, imgPixels, numImages) (out)\n\n * Note: at present, I have no code to compute the meanDiffs. So it should be set\n * to be equal to images. In other words, this isn't really doing contrast normalization,\n * just response normalization.\n */\nvoid convContrastNormCrossMap(NVMatrix& images, NVMatrix& meanDiffs, NVMatrix& target,\n int numFilters, int sizeF, float addScale, float powScale, float minDiv, bool blocked) {\n int numImages = images.getNumCols();\n int imgPixels = images.getNumRows() / numFilters;\n assert(images.getNumRows() == numFilters * imgPixels);\n int imgSize = int(sqrt(imgPixels));\n assert(imgSize * imgSize == imgPixels);\n assert(meanDiffs.isSameDims(images));\n assert(sizeF > 0 && sizeF <= numFilters);\n\n assert(!meanDiffs.isTrans());\n assert(!images.isTrans());\n assert(images.isContiguous());\n assert(meanDiffs.isContiguous());\n assert(numFilters % 16 == 0);\n\n target.resize(images);\n// denoms.resize(images);\n assert(target.isContiguous());\n\n bool checkCaseBounds = numImages % 128 != 0;\n\n dim3 threads(32, 4);\n dim3 blocks(DIVUP(numImages,32*4) * imgSize, (numFilters / 4) * imgSize);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n// printf(\"convContrastNormCrossMap imgs: %p, meanDiffs: %p, denoms: %p, target: %p, imgSize: %d, numFilters: %d, numImages: %d, sizeF: %d, addScale: %f, powScale: %f, minDiv: %f, blocked: %d\\n\",\n// images.getDevData(), meanDiffs.getDevData(), denoms.getDevData(), target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv, blocked);\n if (blocked) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kFCNorm<4, 32, 4, true, true>, cudaFuncCachePreferL1);\n kFCNorm<4, 32, 4, true, true><<>>(images.getTextureObject(), meanDiffs.getTextureObject(), target.getDevData(),\n imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kFCNorm<4, 32, 4, false, true>, cudaFuncCachePreferL1);\n kFCNorm<4, 32, 4, false, true><<>>(images.getTextureObject(), meanDiffs.getTextureObject(), target.getDevData(),\n imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kFCNorm<4, 32, 4, true, false>, cudaFuncCachePreferL1);\n kFCNorm<4, 32, 4, true, false><<>>(images.getTextureObject(), meanDiffs.getTextureObject(), target.getDevData(),\n imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv);\n } else {\n cudaFuncSetCacheConfig(kFCNorm<4, 32, 4, false, false>, cudaFuncCachePreferL1);\n kFCNorm<4, 32, 4, false, false><<>>(images.getTextureObject(), meanDiffs.getTextureObject(), target.getDevData(),\n imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv);\n }\n }\n\n getLastCudaError(\"convContrastNormCrossMap: kernel execution failed\");\n}\n\n/*\n * outGrads: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages)\n * inputs: (numFilters, imgPixels, numImages)\n * acts: (numFilters, imgPixels, numImages)\n * target: (numFilters, imgPixels, numImages)\n *\n * THIS WILL OVERWRITE THE ACTS MATRIX.\n */\nvoid convResponseNormCrossMapUndo(NVMatrix& outGrads, NVMatrix& inputs, NVMatrix& acts, NVMatrix& target, int numFilters,\n int sizeF, float addScale, float powScale, float minDiv, bool blocked, float scaleTargets, float scaleOutput) {\n int numImages = outGrads.getNumCols();\n int imgPixels = outGrads.getNumRows() / numFilters;\n\n int imgSize = int(sqrt(imgPixels));\n assert(imgSize * imgSize == imgPixels);\n assert(sizeF > 0 && sizeF <= numFilters);\n assert(outGrads.getNumRows() == numFilters * imgPixels);\n\n assert(!outGrads.isTrans());\n assert(!acts.isTrans());\n assert(!target.isTrans());\n assert(outGrads.isContiguous());\n\n assert(numFilters % 16 == 0);\n\n target.resize(outGrads);\n assert(target.isContiguous());\n // First do acts := -2 x scale x acts x outGrads / denoms\n // so that the main routine only has to do an addition in its inner loop.\n cudaStream_t stream = NVMatrix::getDefaultStream();\n\n dim3 threads2 = dim3(32, 4);\n dim3 blocks2 = dim3(DIVUP(numImages,32*4) * imgSize, (numFilters / 4) * imgSize);\n\n bool checkCaseBounds = (numImages % 128) != 0;\n if (blocked) {\n if (scaleTargets == 0 && scaleOutput == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, false, true, true>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, false, true, true><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, false, false, true>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, false, false, true><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, true, true, true>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, true, true, true><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, true, false, true>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, true, false, true><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n }\n }\n } else {\n if (scaleTargets == 0 && scaleOutput == 1) {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, false, true, false>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, false, true, false><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, false, false, false>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, false, false, false><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n }\n } else {\n if (checkCaseBounds) {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, true, true, false>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, true, true, false><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n } else {\n cudaFuncSetCacheConfig(kFRNormUndo2<4, 32, 4, true, false, false>, cudaFuncCachePreferL1);\n kFRNormUndo2<4, 32, 4, true, false, false><<>>(outGrads.getTextureObject(), inputs.getTextureObject(), acts.getTextureObject(),\n target.getDevData(), imgSize, numFilters, numImages, sizeF, addScale, powScale, minDiv,\n scaleTargets, scaleOutput);\n }\n }\n }\n\n getLastCudaError(\"convResponseNormCrossMapUndo: kernel execution failed\");\n}\n\nvoid convResponseNormCrossMap(NVMatrix& images, NVMatrix& target, int numFilters, int sizeF, float addScale, float powScale, float minDiv, bool blocked) {\n convContrastNormCrossMap(images, images, target, numFilters, sizeF, addScale, powScale, minDiv, blocked);\n}\n\n/*\n * images: (numFilters, imgPixels, numImages)\n * denoms: (numFilters, imgPixels, numImages) (out)\n * target: (numFilters, imgPixels, numImages) (out)\n */\nvoid convResponseNormCrossMap(NVMatrix& images, NVMatrix& target, int numFilters, int sizeF, float addScale, float powScale, bool blocked) {\n convContrastNormCrossMap(images, images, target, numFilters, sizeF, addScale, powScale, 1, blocked);\n}\n\ncudaTextureObject_t GetTensorTextureObject(caffe2::TensorCUDA* tensor) {\n cudaTextureObject_t tex_obj;\n cudaResourceDesc res_desc;\n std::memset(&res_desc, 0, sizeof(res_desc));\n res_desc.resType = cudaResourceTypeLinear;\n res_desc.res.linear.devPtr = tensor->mutable_data();\n res_desc.res.linear.sizeInBytes = tensor->nbytes();\n res_desc.res.linear.desc =\n cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);\n cudaTextureDesc tex_desc;\n std::memset(&tex_desc, 0, sizeof(tex_desc));\n CUDA_ENFORCE(\n cudaCreateTextureObject(&tex_obj, &res_desc, &tex_desc, nullptr));\n return tex_obj;\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/filter_acts.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"../include/cudaconv2.cuh\"\n\n__device__ __forceinline__ void filterActs_YxX_color_preload_ty_4_tx_32_f_16_cc_3_setImgCoords(int fPidx, int imgLoadModPosY, int imgLoadModPosX,\n int imgSizeX, int filterSize, int& iPidx) {\n int x = imgLoadModPosX + (fPidx) % filterSize;\n int y = imgLoadModPosY + (fPidx) / filterSize;\n iPidx = y >= 0 && y < imgSizeX && x >= 0 && x < imgSizeX ? y * imgSizeX + x : -1;\n}\n\n#define FA_COLOR3_IMPRELOAD(c,i) imPreload[c][i] = iPidxNext < 0 || (checkImgBounds && myImgIdx + i * B_X >= numImages) ? 0 : mm[c * imgPixels * imgStride + i * B_X];\n#define FA_COLOR3_IMPRELOAD_TX(c,i) imPreload[c][i] = iPidxNext < 0 || (checkImgBounds && myImgIdx + i * B_X >= numImages) ? 0 : tex1Dfetch(images, imagesOffset2 + c * imgPixels * imgStride + i * B_X);\n\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages) with stride given\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModules, numFilterColors, filterPixels, numFilters) otherwise\n *\n * targets: (numFilters, numModulesY, numModulesX, numImages)\n *\n */\ntemplate \n//__launch_bounds__(128,3)\n__global__ void filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_16_px_4_cc_3_tex(cudaTextureObject_t images, cudaTextureObject_t filters, float* targets,\n const int numImages, const int numFilters,\n const int imgSizeY, const int imgSizeX, const int filterSize, const int paddingStart,\n const int moduleStride,\n const int numModulesY, const int numModulesX, const int imgStride,\n const float scaleTargets, const float scaleOutputs,\n const bool conv/*, const bool noloads*/) {\n __shared__ float shFilters[numColors][pixelCache][B_Y * filtersPerThread]; // pre-load 1 pixel from B_Y*filtersPerThread filters\n __shared__ float shImages[numColors][pixelCache][B_X * imgsPerThread]; // pre-load 1 pixel from B_X*imgsPerThread images\n const int imgPixels = imgSizeY * imgSizeX;\n const int filterPixels = filterSize * filterSize;\n const int blocksPerModule = numFilters / (B_Y*filtersPerThread);\n const int moduleIdx = blockIdx.y / blocksPerModule;\n const int blockFilterIdx = filtersPerThread * B_Y * (blockIdx.y % blocksPerModule);\n\n const int numModules = numModulesX * numModulesY;\n // Another fun insanity: the % B_X makes things faster, even thought threadIdx.x is\n // in the range 0..31. It appears that this allows the compiler to optimize?\n const int tx = threadIdx.x % B_X;\n const int ty = threadIdx.y % B_Y;\n const int tidx = ty * B_X + threadIdx.x;\n\n const int imgLoadModPosY = paddingStart + (moduleIdx / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (moduleIdx % numModulesX) * moduleStride;\n\n const int shFilterLoadY = tidx / (B_Y * filtersPerThread);\n const int shFilterLoadX = tidx % (B_Y * filtersPerThread);\n const int myImgIdx = blockIdx.x * B_X * imgsPerThread + threadIdx.x;\n\n// images += myImgIdx;\n// filters += blockFilterIdx\n// + shFilterLoadY * numFilters + shFilterLoadX;\n// if (!conv) { // NOTE: UNTESTED!\n// filters += moduleIdx * numColors * filterPixels * numFilters;\n// }\n\n const int imagesOffset = myImgIdx;\n const int filtersOffset = blockFilterIdx + shFilterLoadY * numFilters + shFilterLoadX\n + (conv ? 0 : moduleIdx * numColors * filterPixels * numFilters);\n\n targets += moduleIdx * numImages\n + (blockFilterIdx + threadIdx.y * filtersPerThread) * numImages * numModules\n + myImgIdx;\n\n float prod[imgsPerThread][filtersPerThread];\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] = 0;\n }\n }\n\n int iPidxNext;\n float imPreload[numColors][imgsPerThread];\n float fPreload[numColors][pixelCache*filtersPerThread/B_X];\n\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n #pragma unroll\n for (int p = 0; p < pixelCache; p += B_X/filtersPerThread) {\n if (p + shFilterLoadY < filterPixels) {\n fPreload[c][p*filtersPerThread/B_X] = tex1Dfetch(filters, filtersOffset + p * numFilters + c * numFilters * filterPixels);\n } else{\n fPreload[c][p*filtersPerThread/B_X] = 0;\n }\n }\n }\n\n filterActs_YxX_color_preload_ty_4_tx_32_f_16_cc_3_setImgCoords(ty, imgLoadModPosY, imgLoadModPosX, imgSizeX, filterSize, iPidxNext);\n\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (iPidxNext >= 0 && (!checkImgBounds || myImgIdx + i * B_X < numImages)) {\n imPreload[c][i] = tex1Dfetch(images, imagesOffset + (c * imgPixels + iPidxNext) * imgStride + i * B_X);\n } else {\n imPreload[c][i] = 0;\n }\n }\n }\n\n for (int p = 0; p < filterPixels; p += pixelCache) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n // NOTE: bank conflicts here!\n shImages[c][ty][tx * imgsPerThread + i] = imPreload[c][i];\n }\n }\n\n const int fPidxNext = p + pixelCache >= filterPixels ? 0 : p + pixelCache;\n filterActs_YxX_color_preload_ty_4_tx_32_f_16_cc_3_setImgCoords(fPidxNext + ty, imgLoadModPosY, imgLoadModPosX, imgSizeX, filterSize, iPidxNext);\n\n// const float* ff = &filters[numFilters * fPidxNext];\n// const float* mm = &images[imgStride * iPidxNext];\n const int filtersOffset2 = filtersOffset + numFilters * fPidxNext;\n const int imagesOffset2 = imagesOffset + imgStride * iPidxNext;\n\n FA_COLOR3_IMPRELOAD_TX(0,0);\n FA_COLOR3_IMPRELOAD_TX(0,1);\n FA_COLOR3_IMPRELOAD_TX(0,2);\n FA_COLOR3_IMPRELOAD_TX(0,3);\n\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n #pragma unroll\n for (int pp = 0; pp < pixelCache; pp += B_X/filtersPerThread) {\n shFilters[c][pp + shFilterLoadY][shFilterLoadX] = fPreload[c][pp*filtersPerThread/B_X];\n }\n }\n\n __syncthreads();\n FA_COLOR3_IMPRELOAD_TX(1,0);\n FA_COLOR3_IMPRELOAD_TX(1,1);\n FA_COLOR3_IMPRELOAD_TX(1,2);\n FA_COLOR3_IMPRELOAD_TX(1,3);\n FA_COLOR3_IMPRELOAD_TX(2,0);\n FA_COLOR3_IMPRELOAD_TX(2,1);\n FA_COLOR3_IMPRELOAD_TX(2,2);\n FA_COLOR3_IMPRELOAD_TX(2,3);\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int pp = 0; pp < pixelCache*filtersPerThread/B_X; pp++) {\n fPreload[c][pp] = fPidxNext + pp*(B_X/filtersPerThread) + shFilterLoadY >= filterPixels ? 0 : tex1Dfetch(filters, filtersOffset2 + c * numFilters* filterPixels + pp*(B_X/filtersPerThread) * numFilters);\n }\n }\n #pragma unroll\n for (int pp = 0; pp < pixelCache; pp++) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n prod[i][f] += shImages[c][pp][tx * imgsPerThread + i] * shFilters[c][pp][ty * filtersPerThread + f];\n }\n }\n }\n }\n\n __syncthreads();\n }\n\n if (scale) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n targets[i * B_X + f * numImages * numModules] = scaleTargets * targets[i * B_X + f * numImages * numModules] + scaleOutputs * prod[i][f];\n }\n }\n }\n } else {\n // Note: reversing order of these loops saves 2 registers, but costs time\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n targets[i * B_X + f * numImages * numModules] = scaleOutputs * prod[i][f];\n }\n }\n }\n }\n}\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages) with stride given\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModules, numFilterColors, filterPixels, numFilters) otherwise\n *\n * targets: (numFilters, numModulesY, numModulesX, numImages)\n *\n * This won't be pretty.\n */\ntemplate \n__global__ void filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_12_px_4_cc_3_tex(cudaTextureObject_t images, cudaTextureObject_t filters, float* targets,\n const int numImages, const int numFilters,\n const int imgSizeY, const int imgSizeX, const int filterSize, const int paddingStart,\n const int moduleStride,\n const int numModulesY, const int numModulesX, const int imgStride,\n const float scaleTargets, const float scaleOutputs,\n const bool conv/*, const bool noloads*/) {\n __shared__ float shFilters[numColors][pixelCache][B_Y * filtersPerThread]; // pre-load 1 pixel from B_Y*filtersPerThread filters\n __shared__ float shImages[numColors][pixelCache][B_X * imgsPerThread]; // pre-load 1 pixel from B_X*imgsPerThread images\n const int imgPixels = imgSizeY * imgSizeX;\n const int filterPixels = filterSize * filterSize;\n const int blocksPerModule = numFilters / (B_Y*filtersPerThread);\n const int moduleIdx = blockIdx.y / blocksPerModule;\n const int blockFilterIdx = filtersPerThread * B_Y * (blockIdx.y % blocksPerModule);\n\n const int numModules = numModulesX * numModulesY;\n // Another fun insanity: the % B_X makes things faster, even though threadIdx.x is\n // in the range 0..31. It appears that this allows the compiler to optimize?\n const int tx = threadIdx.x % B_X;\n const int ty = threadIdx.y % B_Y;\n const int tidx = ty * B_X + threadIdx.x;\n const int warp = tidx / 32;\n\n const int imgLoadModPosY = paddingStart + (moduleIdx / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (moduleIdx % numModulesX) * moduleStride;\n\n const int shFilterLoadY = tidx / (B_Y * filtersPerThread);\n const int shFilterLoadX = tidx % (B_Y * filtersPerThread);\n const int myImgIdx = blockIdx.x * B_X * imgsPerThread + threadIdx.x;\n\n// images += myImgIdx;\n// filters += blockFilterIdx\n// + shFilterLoadY * numFilters + shFilterLoadX;\n// if (!conv) { // NOTE: UNTESTED!\n// filters += moduleIdx * numColors * filterPixels * numFilters;\n// }\n\n const int imagesOffset = myImgIdx;\n const int filtersOffset = blockFilterIdx + shFilterLoadY * numFilters + shFilterLoadX\n + (conv ? 0 : moduleIdx * numColors * filterPixels * numFilters);\n\n targets += moduleIdx * numImages\n + (blockFilterIdx + threadIdx.y * filtersPerThread) * numImages * numModules\n + myImgIdx;\n\n float prod[imgsPerThread][filtersPerThread];\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] = 0;\n }\n }\n\n int iPidxNext;\n float imPreload[numColors][imgsPerThread];\n float fPreload[numColors][DIVUP(pixelCache*filtersPerThread,B_X)];\n\n if (warp < 3) {\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n #pragma unroll\n for (int p = 0; p < pixelCache; p += 2) {\n if (p + shFilterLoadY < filterPixels) {\n fPreload[c][p/2] = tex1Dfetch(filters, filtersOffset + p * numFilters + c * numFilters * filterPixels);\n } else {\n fPreload[c][p/2] = 0;\n }\n }\n }\n }\n\n filterActs_YxX_color_preload_ty_4_tx_32_f_16_cc_3_setImgCoords(ty, imgLoadModPosY, imgLoadModPosX, imgSizeX, filterSize, iPidxNext);\n\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (iPidxNext >= 0 && (!checkImgBounds || myImgIdx + i * B_X < numImages)) {\n imPreload[c][i] = tex1Dfetch(images, imagesOffset + (c * imgPixels + iPidxNext) * imgStride + i * B_X);\n } else {\n imPreload[c][i] = 0;\n }\n }\n }\n\n for (int p = 0; p < filterPixels; p += pixelCache) {\n const int fPidxNext = p + pixelCache >= filterPixels ? 0 : p + pixelCache;\n filterActs_YxX_color_preload_ty_4_tx_32_f_16_cc_3_setImgCoords(fPidxNext + ty, imgLoadModPosY, imgLoadModPosX, imgSizeX, filterSize, iPidxNext);\n\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n // NOTE: bank conflicts here!\n shImages[c][ty][tx * imgsPerThread + i] = imPreload[c][i];\n }\n }\n\n if (warp < 3) {\n #pragma unroll\n for (int c = 0; c < numColors; ++c) {\n #pragma unroll\n for (int pp = 0; pp < pixelCache; pp += 2) {\n shFilters[c][pp + shFilterLoadY][shFilterLoadX] = fPreload[c][pp/2];\n }\n }\n }\n\n __syncthreads();\n// const float* ff = &filters[numFilters * fPidxNext];\n// const float* mm = &images[imgStride * iPidxNext];\n const int filtersOffset2 = filtersOffset + numFilters * fPidxNext;\n const int imagesOffset2 = imagesOffset + imgStride * iPidxNext;\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; ++i) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n FA_COLOR3_IMPRELOAD_TX(c,i);\n }\n }\n\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int pp = 0; pp < 2; pp++) {\n fPreload[c][pp] = warp >= 3 || fPidxNext + pp*2 + shFilterLoadY >= filterPixels ? 0 : tex1Dfetch(filters, filtersOffset2 + c * numFilters* filterPixels + pp*2 * numFilters);\n }\n #pragma unroll\n for (int pp = 0; pp < pixelCache; pp++) {\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] += shImages[c][pp][tx * imgsPerThread + i] * shFilters[c][pp][ty * filtersPerThread + f];\n }\n }\n }\n\n }\n __syncthreads();\n }\n\n if (scale) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n targets[i * B_X + f * numImages * numModules] = scaleTargets * targets[i * B_X + f * numImages * numModules] + scaleOutputs * prod[i][f];\n }\n }\n }\n } else {\n // Note: reversing order of these loops costs 2 registers, but saves time\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n targets[i * B_X + f * numImages * numModules] = scaleOutputs * prod[i][f];\n }\n }\n }\n }\n}\n\n__device__ inline void filterActs_YxX_sparse2_preload_ty_4_tx_32_f_16_c_4_setPixelCoords(int filterSize, int imgSizeX, int imgLoadModPosY, int imgLoadModPosX, int imgY, int imgX, int& fPidx, int& iPidx) {\n int filterPxY = imgY - imgLoadModPosY;\n int filterPxX = imgX - imgLoadModPosX;\n fPidx = filterPxY * filterSize + filterPxX;\n iPidx = imgY * imgSizeX + imgX; // Pixel index in img\n}\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages) with stride given\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModules, numFilterColors, filterPixels, numFilters) otherwise\n *\n * targets: (numFilters, numModulesY, numModulesX, numImages)\n *\n * Note: in git there's a 1.5% faster version of this which sues 167 registers instead of 154...\n * it's basically the same thing, but it doesn't do the next-pixel computation. It just avoids\n * pre-loading when it rolls over to the next pixel.\n */\ntemplate \n__global__ void filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4(float* images, float* filters, float* targets,\n const int numImages, const int numFilters,\n const int imgSizeY, const int imgSizeX, const int filterSize, const int paddingStart,\n const int moduleStride,\n const int numModulesY, const int numModulesX, const int imgStride, const int numImgColors,\n const int numGroups,\n const float scaleTargets, const float scaleOutputs,\n const bool conv/*, const bool noloads*/) {\n __shared__ float shFilters[colorCache][B_Y * filtersPerThread]; // pre-load 1 pixel from B_Y*filtersPerThread filters\n __shared__ float shImages[colorCache][B_X * imgsPerThread]; // pre-load 1 pixel from B_X*imgsPerThread images\n const int imgPixels = imgSizeY * imgSizeX;\n const int filterPixels = filterSize * filterSize;\n const int numFilterColors = numImgColors / numGroups;\n const int blocksPerModule = numFilters / (B_Y*filtersPerThread);\n const int moduleIdx = blockIdx.y / blocksPerModule;\n const int blockFilterIdx = filtersPerThread * B_Y * (blockIdx.y % blocksPerModule);\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n\n const int numModules = numModulesX * numModulesY;\n const int blockColorIdx = numFilterColors * blockGroupIdx;\n // Another fun insanity: the % B_X makes things faster, even thought threadIdx.x is\n // in the range 0..31. It appears that this allows the compiler to optimize?\n const int tx = threadIdx.x % B_X;\n const int ty = threadIdx.y % B_Y;\n const int tidx = ty * B_X + threadIdx.x;\n\n const int imgLoadModPosY = paddingStart + (moduleIdx / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (moduleIdx % numModulesX) * moduleStride;\n\n const int shFilterLoadY = tidx / (B_Y * filtersPerThread);\n const int shFilterLoadX = tidx % (B_Y * filtersPerThread);\n const int myImgIdx = blockIdx.x * B_X * imgsPerThread + threadIdx.x;\n\n images += (blockColorIdx + threadIdx.y) * imgPixels * imgStride + myImgIdx;\n filters +=blockFilterIdx\n + shFilterLoadY * numFilters * filterPixels + shFilterLoadX;\n if (!conv) {\n filters += moduleIdx * numFilterColors * filterPixels * numFilters;\n }\n\n targets += moduleIdx * numImages\n + (blockFilterIdx + threadIdx.y * filtersPerThread) * numImages * numModules\n + myImgIdx;\n\n float prod[imgsPerThread][filtersPerThread];\n// float fCache[filtersPerThread];\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] = 0;\n }\n }\n // NOTE: these max/min functions increase register usage as compared to my macros\n const int imgStartX = max(0, imgLoadModPosX);\n const int imgStartY = max(0, imgLoadModPosY);\n const int imgEndX = min(imgLoadModPosX + filterSize, imgSizeX);\n const int imgEndY = min(imgLoadModPosY + filterSize, imgSizeY);\n// __shared__ int imgPos[]\n\n int fPidx, iPidx;\n float imPreload[imgsPerThread];\n float fPreload[colorCache*filtersPerThread/B_X];\n// float fCache[filtersPerThread];\n\n filterActs_YxX_sparse2_preload_ty_4_tx_32_f_16_c_4_setPixelCoords(filterSize, imgSizeX, imgLoadModPosY, imgLoadModPosX, imgStartY, imgStartX, fPidx, iPidx);\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n imPreload[i] = images[imgStride * iPidx + i * B_X];\n } else {\n imPreload[i] = 0;\n }\n }\n if (/*B_X % filtersPerThread == 0 ||*/ shFilterLoadY < B_X/filtersPerThread) { // This if statement reduces reg usage..\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_X/filtersPerThread) {\n fPreload[c*filtersPerThread/B_X] = filters[(c * filterPixels + fPidx) * numFilters];\n }\n }\n for (int imgY = imgStartY; imgY < imgEndY; ++imgY) {\n// const int filterPxY = imgY - imgLoadModPosY;\n for (int imgX = imgStartX; imgX < imgEndX; ++imgX) {\n// const int filterPxX = imgX - imgLoadModPosX;\n// const int p = filterPxY * filterSize + filterPxX;\n// const int pixIdx = imgY * imgSizeX + imgX;// Pixel index in img\n// setPixelCoords(filterSize, imgSizeX, imgLoadModPosY, imgLoadModPosX, imgY, imgX, &p, &pixIdx);\n// float* m = &images[imgStride * pixIdx];\n const bool lastPixel = imgY == imgEndY - 1 && imgX == imgEndX - 1;\n int imgYNext = imgY;\n int imgXNext = imgX;\n int fPidxNext, iPidxNext;\n if (!lastPixel) {\n imgYNext = imgY + (imgX + 1 == imgEndX);\n imgXNext = imgX + 1 == imgEndX ? imgStartX : imgX + 1;\n }\n filterActs_YxX_sparse2_preload_ty_4_tx_32_f_16_c_4_setPixelCoords(filterSize, imgSizeX, imgLoadModPosY, imgLoadModPosX, imgYNext, imgXNext, fPidxNext, iPidxNext);\n for (int oc = 0; oc < numFilterColors; oc += colorCache) { // oc stands for outer color (loop)\n const float* ff = &filters[numFilters * ((oc + colorCache) * filterPixels + fPidx)];\n const float* mm = &images[imgStride * ((oc + colorCache) * imgPixels + iPidx)];\n if (oc == numFilterColors - colorCache) {\n ff = &filters[fPidxNext * numFilters];\n mm = &images[iPidxNext * imgStride];\n fPidx = fPidxNext;\n iPidx = iPidxNext;\n }\n\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_X/filtersPerThread) {\n shFilters[c + shFilterLoadY][shFilterLoadX] = fPreload[c*filtersPerThread/B_X];\n }\n\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n // NOTE: bank conflicts here!\n shImages[ty][tx * imgsPerThread + i] = imPreload[i];\n }\n imPreload[0] = (checkImgBounds && myImgIdx + 0 * B_X >= numImages) ? 0 : mm[0 * B_X];\n imPreload[1] = (checkImgBounds && myImgIdx + 1 * B_X >= numImages) ? 0 : mm[1 * B_X];\n imPreload[2] = (checkImgBounds && myImgIdx + 2 * B_X >= numImages) ? 0 : mm[2 * B_X];\n\n __syncthreads();\n\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] += shImages[0][threadIdx.x * imgsPerThread + i] * shFilters[0][threadIdx.y * filtersPerThread + f];\n }\n }\n\n fPreload[0] = ff[0];\n\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] += shImages[1][threadIdx.x * imgsPerThread + i] * shFilters[1][threadIdx.y * filtersPerThread + f];\n }\n }\n\n fPreload[1] = ff[(B_X/filtersPerThread * filterPixels) * numFilters];\n\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] += shImages[2][threadIdx.x * imgsPerThread + i] * shFilters[2][threadIdx.y * filtersPerThread + f];\n }\n }\n\n imPreload[3] = (checkImgBounds && myImgIdx + 3 * B_X >= numImages) ? 0 : mm[3 * B_X];\n\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] += shImages[3][threadIdx.x * imgsPerThread + i] * shFilters[3][threadIdx.y * filtersPerThread + f];\n }\n }\n __syncthreads();\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n targets[i * B_X + f * numImages * numModules] = scaleTargets * targets[i * B_X + f * numImages * numModules] + scaleOutputs * prod[i][f];\n }\n }\n }\n } else {\n // Note: reversing order of these loops saves 2 registers, but costs time\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n targets[i * B_X + f * numImages * numModules] = scaleOutputs * prod[i][f];\n }\n }\n }\n }\n}\n\n/*****************************Function Revision Record*****************************\n * Author: Tencent BestImage Team(ankerguo@tencent.com) *\n * Date: 2015-05-18 *\n * Reason: Optimizing kernel to get faster speed according to GPU features *\n * Method: *\n * 1. reorganizing data structure to avoid bank conflict; *\n * 2. using vectorized data type; *\n * 3. improving instruction-level parallelism; *\n * 4. removing redundant 'if' branches; *\n * 5. removing local variables to save registers. *\n *********************************************************************************/\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages) with stride given\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModules, numFilterColors, filterPixels, numFilters) otherwise\n *\n * targets: (numFilters, numModulesY, numModulesX, numImages)\n *\n */\ntemplate \n__global__ void \n__launch_bounds__(128, 4)\nfilterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex(cudaTextureObject_t images, cudaTextureObject_t filters, float* targets,\n const int numImages, const int numFilters,\n const int imgSizeY, const int imgSizeX, const int filterSize, const int paddingStart,\n const int moduleStride,\n const int numModulesY, const int numModulesX, const int imgStride, const int numImgColors,\n const int numGroups,\n const float scaleTargets, const float scaleOutputs,\n const bool conv/*, const bool noloads*/) {\n // avoid bank conflict by reorganizing the data structure and improve the band width by using 'float2' instead of 'float'\n __shared__ float2 shFilters[colorCache / 2][B_Y * filtersPerThread]; // pre-load 1 pixel from B_Y*filtersPerThread filters\n __shared__ float2 shImages[colorCache][B_X * imgsPerThread / 2]; // pre-load 1 pixel from B_X*imgsPerThread images\n const int imgPixels = imgSizeY * imgSizeX;\n const int filterPixels = filterSize * filterSize;\n const int numFilterColors = numImgColors / numGroups;\n const int blocksPerModule = numFilters / (B_Y*filtersPerThread);\n const int moduleIdx = blockIdx.y / blocksPerModule;\n const int blockFilterIdx = filtersPerThread * B_Y * (blockIdx.y % blocksPerModule);\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n\n const int numModules = numModulesX * numModulesY;\n const int blockColorIdx = numFilterColors * blockGroupIdx;\n // Another fun insanity: the % B_X makes things faster, even thought threadIdx.x is\n // in the range 0..31. It appears that this allows the compiler to optimize?\n const int tx = threadIdx.x % B_X;\n const int ty = threadIdx.y % B_Y;\n //const int tidx = ty * B_X + threadIdx.x; // reduce one register\n\n const int imgLoadModPosY = paddingStart + (moduleIdx / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (moduleIdx % numModulesX) * moduleStride;\n\n // reduce two registers\n //const int shFilterLoadY = tidx / (B_Y * filtersPerThread);\n //const int shFilterLoadX = tidx % (B_Y * filtersPerThread);\n const int myImgIdx = blockIdx.x * B_X * imgsPerThread + tx;\n const int imgOffset = (blockColorIdx + ty) * imgPixels * imgStride + myImgIdx;\n\n// images += (blockColorIdx + threadIdx.y) * imgPixels * imgStride + myImgIdx;\n const int filterOffset = blockFilterIdx\n + ((ty * B_X + tx) / (B_Y * filtersPerThread)) * numFilters * filterPixels + ((ty * B_X + tx) % (B_Y * filtersPerThread)) + (conv ? 0 : moduleIdx * numFilterColors * filterPixels * numFilters);\n// filters +=blockFilterIdx\n// + shFilterLoadY * numFilters * filterPixels + shFilterLoadX;\n// if (!conv) {\n// filters += moduleIdx * numFilterColors * filterPixels * numFilters;\n// }\n\n targets += moduleIdx * numImages\n + (blockFilterIdx + threadIdx.y * filtersPerThread) * numImages * numModules\n + myImgIdx;\n\n // combine two registers into one\n const int numModImages = numModules * numImages;\n float prod[imgsPerThread][filtersPerThread];\n// float fCache[filtersPerThread];\n #pragma unroll\n for(int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[i][f] = 0;\n }\n }\n // NOTE: these max/min functions increase register usage as compared to my macros\n const int imgStartX = max(0, imgLoadModPosX);\n const int imgStartY = max(0, imgLoadModPosY);\n const int imgEndX = min(imgLoadModPosX + filterSize, imgSizeX);\n const int imgEndY = min(imgLoadModPosY + filterSize, imgSizeY);\n// __shared__ int imgPos[]\n\n int fPidx, iPidx;\n float imPreload[imgsPerThread]; // [4]\n float fPreload[colorCache*filtersPerThread/B_X]; // [2]\n// float fCache[filtersPerThread];\n\n filterActs_YxX_sparse2_preload_ty_4_tx_32_f_16_c_4_setPixelCoords(filterSize, imgSizeX, imgLoadModPosY, imgLoadModPosX, imgStartY, imgStartX, fPidx, iPidx);\n\n // remove redundant conditions\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n imPreload[i] = tex1Dfetch(images, imgOffset + imgStride * iPidx + i * B_X);\n }\n\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_X/filtersPerThread) {\n fPreload[c*filtersPerThread/B_X] = tex1Dfetch(filters, filterOffset + (c * filterPixels + fPidx) * numFilters);\n }\n for (int imgY = imgStartY; imgY < imgEndY; ++imgY) {\n// const int filterPxY = imgY - imgLoadModPosY;\n for (int imgX = imgStartX; imgX < imgEndX; ++imgX) {\n// const int filterPxX = imgX - imgLoadModPosX;\n// const int p = filterPxY * filterSize + filterPxX;\n// const int pixIdx = imgY * imgSizeX + imgX;// Pixel index in img\n// setPixelCoords(filterSize, imgSizeX, imgLoadModPosY, imgLoadModPosX, imgY, imgX, &p, &pixIdx);\n// float* m = &images[imgStride * pixIdx];\n const bool lastPixel = imgY == imgEndY - 1 && imgX == imgEndX - 1;\n int imgYNext = imgY;\n int imgXNext = imgX;\n int fPidxNext, iPidxNext;\n if (!lastPixel) {\n imgYNext = imgY + (imgX + 1 == imgEndX);\n imgXNext = imgX + 1 == imgEndX ? imgStartX : imgX + 1;\n }\n filterActs_YxX_sparse2_preload_ty_4_tx_32_f_16_c_4_setPixelCoords(filterSize, imgSizeX, imgLoadModPosY, imgLoadModPosX, imgYNext, imgXNext, fPidxNext, iPidxNext);\n for (int oc = 0; oc < numFilterColors; oc += colorCache) { // oc stands for outer color (loop)\n // store the preloaded pixel of filter and image into shared memory\n shFilters[(ty * B_X + tx) / (B_Y * filtersPerThread)][(ty * B_X + tx) % (B_Y * filtersPerThread)].x = fPreload[0];\n shFilters[(ty * B_X + tx) / (B_Y * filtersPerThread)][(ty * B_X + tx) % (B_Y * filtersPerThread)].y = fPreload[1];\n shImages[ty][tx].x = imPreload[0];\n shImages[ty][tx].y = imPreload[1]; \n shImages[ty][tx+B_X].x = imPreload[2]; \n shImages[ty][tx+B_X].y = imPreload[3];\n\n int imgOffset2 = imgOffset + imgStride * ((oc + colorCache) * imgPixels + iPidx);\n int filterOffset2 = filterOffset + numFilters * ((oc + colorCache) * filterPixels + fPidx);\n if (oc == numFilterColors - colorCache) {\n filterOffset2 = filterOffset + fPidxNext * numFilters;\n imgOffset2 = imgOffset + iPidxNext * imgStride;\n fPidx = fPidxNext;\n iPidx = iPidxNext;\n }\n\n // preload one pixel of filter and image from texture, and no need to check 'checkImgBounds' with all callers setting it as false\n imPreload[0] = tex1Dfetch(images, imgOffset2);\n imPreload[1] = tex1Dfetch(images, imgOffset2 + B_X);\n imPreload[2] = tex1Dfetch(images, imgOffset2 + 2 * B_X);\n imPreload[3] = tex1Dfetch(images, imgOffset2 + 3 * B_X);\n fPreload[0] = tex1Dfetch(filters, filterOffset2);\n fPreload[1] = tex1Dfetch(filters, filterOffset2 + 2 * filterPixels * numFilters);\n\n __syncthreads();\n\n // put together the instructions with same type to improve instruction-level parallelism \n // calculate the convolution between images and filters\n #pragma unroll \n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int r = 0; r < colorCache / 2; r++) {\n prod[0][f] += shImages[r][tx].x * shFilters[r][ty*filtersPerThread+f].x;\n prod[1][f] += shImages[r][tx].y * shFilters[r][ty*filtersPerThread+f].x;\n prod[2][f] += shImages[r][tx+B_X].x * shFilters[r][ty*filtersPerThread+f].x;\n prod[3][f] += shImages[r][tx+B_X].y * shFilters[r][ty*filtersPerThread+f].x;\n prod[0][f] += shImages[r+2][tx].x * shFilters[r][ty*filtersPerThread+f].y;\n prod[1][f] += shImages[r+2][tx].y * shFilters[r][ty*filtersPerThread+f].y;\n prod[2][f] += shImages[r+2][tx+B_X].x * shFilters[r][ty*filtersPerThread+f].y;\n prod[3][f] += shImages[r+2][tx+B_X].y * shFilters[r][ty*filtersPerThread+f].y;\n }\n }\n __syncthreads();\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n // remove the redundant condition for less registers\n targets[i * B_X + f * numModImages] = scaleTargets * targets[i * B_X + f * numModImages] + scaleOutputs * prod[i][f];\n }\n }\n } else {\n // Note: reversing order of these loops saves 2 registers, but costs time\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n // remove the redundant condition for less registers\n targets[i * B_X + f * numModImages] = scaleOutputs * prod[i][f];\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X. Each block applies B_Y * filtersPerThread filters to B_X * imgsPerThread images.\n * threadIdx.x determines image\n * threadIdx.y determines filter\n *\n * blockIdx.x determines image batch of B_X * imgsPerThread\n * blockIdx.y determines filter batch of module and B_Y * filtersPerThread\n *\n * images: (numColors, imgSizeY, imgSizeX, numImages) with stride given\n * filters: (numColors, filterPixels, numFilters) if conv\n * (numModules, numColors, filterPixels, numFilters) otherwise\n *\n * targets: (numFilters, numModulesY, numModulesX, numImages)\n *\n *\n * Number of filters per module should be divisible by B_Y * filtersPerThread\n * checkImgBounds indicates whether number of images is divisible by B_X * imgsPerThread\n *\n * The imgSize here is the size of the actual image without the padding.\n *\n */\n template \n__global__ void filterActs_YxX_color(float* images, float* filters, float* targets,\n const int numImages, const int numFilters,\n const int imgSizeY, const int imgSizeX, const int filterSize, const int paddingStart,\n const int moduleStride,\n const int numModulesY, const int numModulesX, const int imgStride,\n const float scaleTargets, const float scaleOutputs,\n const bool conv) {\n __shared__ float shFilters[pixelCache*numColors][B_Y * filtersPerThread]; // pre-load pixelCache pixels from B_Y*filtersPerThread filters\n __shared__ float shImages[pixelCache*numColors][B_X * imgsPerThread]; // pre-load pixelCache pixels from B_X*imgsPerThread images\n const int imgPixels = imgSizeY * imgSizeX;\n const int filterPixels = filterSize * filterSize;\n\n const int blocksPerModule = numFilters / (B_Y*filtersPerThread);\n const int moduleIdx = blockIdx.y / blocksPerModule;\n const int blockFilterIdx = blockIdx.y % blocksPerModule;\n\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n\n const int imgLoadModPosY = paddingStart + (moduleIdx / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (moduleIdx % numModulesX) * moduleStride;\n const int numModules = numModulesY * numModulesX;\n const int shFilterLoadY = tidx / (B_Y * filtersPerThread);\n const int shFilterLoadX = tidx % (B_Y * filtersPerThread);\n const int myImgIdx = blockIdx.x * B_X * imgsPerThread + threadIdx.x;\n images += myImgIdx;\n filters += filtersPerThread * B_Y * blockFilterIdx\n + shFilterLoadY * numFilters + shFilterLoadX;\n if (!conv) {\n filters += moduleIdx * numColors * filterPixels * numFilters;\n }\n\n targets += moduleIdx * numImages\n + (blockFilterIdx * B_Y * filtersPerThread + threadIdx.y*filtersPerThread) * numImages * numModulesY * numModulesX\n + myImgIdx;\n\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for(int g = 0; g < imgsPerThread; g++) {\n prod[f][g] = 0;\n }\n }\n //float* shImgLoad = &shImages[0][threadIdx.x];\n for (int p = 0; p < filterPixels; p += pixelCache) {\n /*\n * Load pixelCache pixels from B_Y*filtersPerThread filters\n * This condition covers the case when B_X is not divisible by filtersPerThread.\n * In this case, not all of the threads will participate in the loading operation.\n * This ensures that in each loop iteration, an integer number of rows of shFilters\n * are filled, which makes indexing simple.\n */\n if (B_X % filtersPerThread == 0 || shFilterLoadY < B_X/filtersPerThread) {\n #pragma unroll\n for (int p2 = 0; p2 < pixelCache; p2 += B_X/filtersPerThread) {\n const bool omit = pixelCache % (B_X / filtersPerThread) == 0;\n const int preloadPx = shFilterLoadY + p2;\n if (omit || preloadPx < pixelCache) {\n if (p + preloadPx < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shFilters[shFilterLoadY + p2 + c * pixelCache][shFilterLoadX] = filters[(c * filterPixels + p + p2) * numFilters];\n }\n } else {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shFilters[shFilterLoadY + p2 + c * pixelCache][shFilterLoadX] = 0;\n }\n }\n }\n }\n }\n\n /*\n * Load pixelCache pixels from B_X*imgsPerThread images.\n */\n #pragma unroll\n for (int ly = 0; ly < pixelCache; ly += B_Y) {\n const int preloadPx = ly + threadIdx.y;\n const int pixIdx = p + preloadPx;\n const bool omit = pixelCache % B_Y == 0; // Compile-time condition\n /*\n * Don't load any image pixels corresponding to filter pixels that don't exist.\n */\n if (pixIdx < filterPixels && (omit || preloadPx < pixelCache)) {\n const int x = imgLoadModPosX + pixIdx % filterSize;\n const int y = imgLoadModPosY + pixIdx / filterSize;\n\n if (y >= 0 && y < imgSizeY && x >= 0 && x < imgSizeX) {\n float* m = &images[imgStride * (y * imgSizeX + x)];\n\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n shImages[preloadPx + c * pixelCache][threadIdx.x * imgsPerThread + i] = m[c * imgStride * imgPixels + i * B_X];\n } else {\n shImages[preloadPx + c * pixelCache][threadIdx.x * imgsPerThread + i] = 0;\n }\n }\n }\n } else { // Padding\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[preloadPx + c * pixelCache][threadIdx.x * imgsPerThread + i] = 0;\n }\n }\n }\n }\n }\n\n __syncthreads();\n\n #pragma unroll\n for (int i = 0; i < pixelCache*numColors; i++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for(int g = 0; g < imgsPerThread; g++) {\n prod[f][g] += shImages[i][g + threadIdx.x * imgsPerThread] * shFilters[i][threadIdx.y * filtersPerThread + f];\n }\n }\n }\n __syncthreads();\n }\n\n if (scale) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int g = 0; g < imgsPerThread; g++) {\n if (!checkImgBounds || myImgIdx + g * B_X < numImages) {\n targets[g * B_X + f * numImages * numModules] = scaleTargets * targets[g * B_X + f * numImages * numModules] + scaleOutputs * prod[f][g];\n }\n }\n }\n } else {\n #pragma unroll\n for (int g = 0; g < imgsPerThread; g++) {\n if (!checkImgBounds || myImgIdx + g * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[g * B_X + f * numImages * numModules] = scaleOutputs * prod[f][g];\n }\n }\n }\n }\n}\n\n/*\n * Block size B_YxB_X. Each block applies B_Y * filtersPerThread filters to B_X * imgsPerThread images.\n * threadIdx.x determines image\n * threadIdx.y determines filter\n *\n * blockIdx.x determines image batch of B_X * imgsPerThread\n * blockIdx.y determines filter batch of B_Y * filtersPerThread\n *\n * images: (numImgColors, imgSizeY, imgSizeX, numImages) with stride given\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModules, numFilterColors, filterPixels, numFilters) otherwise\n *\n * targets: (numFilters, numModulesY, numModulesX, numImages)\n *\n * B_Y one of 4, 8, 16\n * B_X one of 16, 32\n * imgsPerThread one of 1, 2, 4\n * filtersPerThread one of 1, 2, 4, 8\n * colorCache: how many colors to put into shmem\n *\n * numFilters should be divisible by B_Y * filtersPerThread\n * numImages be divisible by B_X * imgsPerThread\n * numFilterColors should be divisible by colorCache.\n * numImgColors must be even.\n * numFilters must be divisible by numGroups.\n * no restrictions on pixelCache\n * The imgSize here is the size of the actual image without the padding.\n * As always, try to make B_X * imgsPerThread == B_Y * filtersPerThread for maximum efficiency.\n *\n */\ntemplate \n__global__ void filterActs_YxX_sparse2(float* images, float* filters, float* targets,\n const int numImages, const int numFilters,\n const int imgSizeY, const int imgSizeX, const int filterSize, const int paddingStart,\n const int moduleStride,\n const int numModulesY, const int numModulesX, const int imgStride, const int numImgColors,\n const int numGroups, \n const float scaleTargets, const float scaleOutputs,\n const bool conv) {\n __shared__ float shFilters[colorCache][B_Y * filtersPerThread]; // pre-load 1 pixel from B_Y*filtersPerThread filters\n __shared__ float shImages[colorCache][B_X * imgsPerThread]; // pre-load 1 pixel from B_X*imgsPerThread images\n const int imgPixels = imgSizeY * imgSizeX;\n const int filterPixels = filterSize * filterSize;\n const int numFilterColors = numImgColors / numGroups;\n const int blocksPerModule = numFilters / (B_Y*filtersPerThread);\n const int moduleIdx = blockIdx.y / blocksPerModule;\n const int blockFilterIdx = filtersPerThread * B_Y * (blockIdx.y % blocksPerModule);\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n\n const int numModules = numModulesX * numModulesY;\n const int blockColorIdx = numFilterColors * blockGroupIdx;\n\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n\n const int imgLoadModPosY = paddingStart + (moduleIdx / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (moduleIdx % numModulesX) * moduleStride;\n\n const int shFilterLoadY = tidx / (B_Y * filtersPerThread);\n const int shFilterLoadX = tidx % (B_Y * filtersPerThread);\n const int myImgIdx = blockIdx.x * B_X * imgsPerThread + threadIdx.x;\n\n images += (blockColorIdx + threadIdx.y) * imgPixels * imgStride + myImgIdx;\n filters +=blockFilterIdx\n + shFilterLoadY * numFilters * filterPixels + shFilterLoadX;\n if (!conv) {\n filters += moduleIdx * numFilterColors * filterPixels * numFilters;\n }\n\n targets += moduleIdx * numImages\n + (blockFilterIdx + threadIdx.y) * numImages * numModules\n + myImgIdx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for(int g = 0; g < imgsPerThread; g++) {\n prod[f][g] = 0;\n }\n }\n const int imgStartX = MAX(0, imgLoadModPosX);\n const int imgStartY = MAX(0, imgLoadModPosY);\n const int imgEndX = MIN(imgLoadModPosX + filterSize, imgSizeX);\n const int imgEndY = MIN(imgLoadModPosY + filterSize, imgSizeY);\n// __shared__ int imgPos[]\n\n for (int imgY = imgStartY; imgY < imgEndY; ++imgY) {\n const int filterPxY = imgY - imgLoadModPosY;\n for (int imgX = imgStartX; imgX < imgEndX; ++imgX) {\n const int filterPxX = imgX - imgLoadModPosX;\n const int p = filterPxY * filterSize + filterPxX;\n for (int oc = 0; oc < numFilterColors; oc += colorCache) { // oc stands for outer color (loop)\n\n /*\n * Load a pixel from B_Y*filtersPerThread filters\n * This condition covers the case when B_X is not divisible by filtersPerThread.\n * In this case, not all of the threads will participate in the loading operation.\n * This ensures that in each loop iteration, an integer number of rows of shFilters\n * are filled, which makes indexing simple.\n\n * nvcc is behaving in a completely insane way: removing this condition under\n * template parameters that guarantee it to be true actually slows down\n * the computation.\n *\n */\n if (/*B_X % filtersPerThread == 0 ||*/ shFilterLoadY < B_X/filtersPerThread) {\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_X/filtersPerThread) {\n if (colorCache % (B_X/filtersPerThread) == 0 || c + shFilterLoadY < colorCache) {\n shFilters[c + shFilterLoadY][shFilterLoadX] = filters[((oc+c) * filterPixels + p) * numFilters];\n }\n }\n }\n\n /*\n * Load a pixel from B_X*imgsPerThread images.\n */\n const int pixIdx = imgY * imgSizeX + imgX;// Pixel index in img\n\n float* m = &images[imgStride * (oc * imgPixels + pixIdx)];\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y) {\n if (colorCache % B_Y == 0 || threadIdx.y + c < colorCache) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkImgBounds || myImgIdx + i * B_X < numImages) {\n shImages[c + threadIdx.y][threadIdx.x + i * B_X] = m[c * imgStride * imgPixels + i * B_X];\n } else {\n shImages[c + threadIdx.y][threadIdx.x + i * B_X] = 0;\n }\n }\n }\n }\n\n __syncthreads();\n\n for (int c = 0; c < colorCache; c++) {\n #pragma unroll\n for(int g = 0; g < imgsPerThread; g++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[f][g] += shImages[c][g * B_X + threadIdx.x] * shFilters[c][threadIdx.y + f * B_Y];\n }\n }\n }\n __syncthreads();\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int g = 0; g < imgsPerThread; g++) {\n if (!checkImgBounds || myImgIdx + g * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[g * B_X + f * B_Y * numImages * numModules] = scaleTargets * targets[g * B_X + f * B_Y * numImages * numModules] + scaleOutputs * prod[f][g];\n }\n }\n }\n } else {\n // Note: reversing order of these loops saves 2 registers, but costs time\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int g = 0; g < imgsPerThread; g++) {\n if (!checkImgBounds || myImgIdx + g * B_X < numImages) {\n targets[g * B_X + f * B_Y * numImages * numModules] = scaleOutputs * prod[f][g];\n }\n }\n }\n }\n}\n\n\n/*****************************Function Revision Record*****************************\n * Author: Tencent BestImage Team(ankerguo@tencent.com) *\n * Date: 2015-05-18 *\n * Reason: Optimizing kernel to get faster speed according to GPU features *\n * Method: *\n * 1. reorganizing data structure to avoid bank conflict; *\n * 2. using vectorized data type; *\n * Note: This function can be used when each thread loads even number of filter *\n * pixels(filtersPerThread * colorCache / B_X is even), and this can be *\n * optimized more when the number of loaded image's pixel is even. *\n *********************************************************************************/\ntemplate \n__global__ void filterActs_YxX_sparse2_f_vec(float* images, float* filters, float* targets,\n const int numImages, const int numFilters,\n const int imgSizeY, const int imgSizeX, const int filterSize, const int paddingStart,\n const int moduleStride,\n const int numModulesY, const int numModulesX, const int imgStride, const int numImgColors,\n const int numGroups, \n const float scaleTargets, const float scaleOutputs,\n const bool conv) {\n // improve shared memory's band width by using 'float2' instead of 'float'\n __shared__ float2 shFilters[colorCache/2][B_Y * filtersPerThread]; // pre-load 1 pixel from B_Y*filtersPerThread filters\n __shared__ float shImages[colorCache][B_X * imgsPerThread]; // pre-load 1 pixel from B_X*imgsPerThread images\n\n const int tx = threadIdx.x % B_X, ty = threadIdx.y % B_Y;\n const int imgPixels = imgSizeY * imgSizeX;\n const int filterPixels = filterSize * filterSize;\n const int numFilterColors = numImgColors / numGroups;\n const int blocksPerModule = numFilters / (B_Y*filtersPerThread);\n const int moduleIdx = blockIdx.y / blocksPerModule;\n const int blockFilterIdx = filtersPerThread * B_Y * (blockIdx.y % blocksPerModule);\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n\n const int numModules = numModulesX * numModulesY;\n const int blockColorIdx = numFilterColors * blockGroupIdx;\n\n const int tidx = ty * B_X + tx;\n\n const int imgLoadModPosY = paddingStart + (moduleIdx / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (moduleIdx % numModulesX) * moduleStride;\n\n // load position of filters' pixels for current thread\n const int shFilterLoadY = tidx / (B_Y * filtersPerThread);\n const int shFilterLoadX = tidx % (B_Y * filtersPerThread);\n // load position of images' pixels for current thread\n const int shImgLoadY = tidx / (B_X * imgsPerThread);\n const int shImgLoadX = tidx % (B_X * imgsPerThread);\n\n const int myImgIdx = blockIdx.x * B_X * imgsPerThread + shImgLoadX;\n images += (blockColorIdx + shImgLoadY) * imgPixels * imgStride + myImgIdx;\n\n filters +=blockFilterIdx\n + shFilterLoadY * numFilters * filterPixels + shFilterLoadX;\n if (!conv) {\n filters += moduleIdx * numFilterColors * filterPixels * numFilters;\n }\n\n targets += moduleIdx * numImages\n + (blockFilterIdx + ty) * numImages * numModules\n + blockIdx.x * B_X * imgsPerThread + tx;\n\n float prod[filtersPerThread][imgsPerThread];\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for(int g = 0; g < imgsPerThread; g++) {\n prod[f][g] = 0;\n }\n }\n\n const int imgStartX = MAX(0, imgLoadModPosX);\n const int imgStartY = MAX(0, imgLoadModPosY);\n const int imgEndX = MIN(imgLoadModPosX + filterSize, imgSizeX);\n const int imgEndY = MIN(imgLoadModPosY + filterSize, imgSizeY);\n\n // temporary buffer to store the filter's loaded pixels during each loop\n float fPreload[colorCache * filtersPerThread / B_X];\n // temporary buffer to store the image's loaded pixels during each loop\n float iPreload[colorCache * imgsPerThread / B_Y];\n\n // preload filter's pixels\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_X/filtersPerThread) {\n fPreload[c * filtersPerThread / B_X] = filters[(c * filterPixels + (imgStartY - imgLoadModPosY) * filterSize + (imgStartX - imgLoadModPosX)) * numFilters];\n }\n\n // preload image's pixels\n if (!checkImgBounds || myImgIdx < numImages) {\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y / imgsPerThread) {\n iPreload[c * imgsPerThread / B_Y] = images[(c * imgPixels + imgStartY * imgSizeX + imgStartX) * imgStride];\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y / imgsPerThread) {\n iPreload[c * imgsPerThread / B_Y] = 0;\n }\n }\n\n for (int imgY = imgStartY; imgY < imgEndY; ++imgY) {\n //const int filterPxY = imgY - imgLoadModPosY;\n for (int imgX = imgStartX; imgX < imgEndX; ++imgX) {\n for (int oc = 0; oc < numFilterColors; oc += colorCache) { // oc stands for outer color (loop)\n // store the preloaded filter's pixels into shared memory\n #pragma unroll\n for (int c = 0; c < colorCache / 2; c += B_X / filtersPerThread) {\n shFilters[c + shFilterLoadY][shFilterLoadX].x = fPreload[c * filtersPerThread / B_X];\n shFilters[c + shFilterLoadY][shFilterLoadX].y = fPreload[(c + colorCache / 2) * filtersPerThread / B_X];\n }\n\n // store the preloaded image's pixels into shared memory\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y / imgsPerThread) {\n shImages[c + shImgLoadY][shImgLoadX] = iPreload[c * imgsPerThread / B_Y];\n }\n /*\n * Load a pixel from B_Y*filtersPerThread filters\n * This condition covers the case when B_X is not divisible by filtersPerThread.\n * In this case, not all of the threads will participate in the loading operation.\n * This ensures that in each loop iteration, an integer number of rows of shFilters\n * are filled, which makes indexing simple.\n\n * nvcc is behaving in a completely insane way: removing this condition under\n * template parameters that guarantee it to be true actually slows down\n * the computation.\n *\n */\n\n /* preload image and filter pixels' data */\n if ((oc + colorCache) == numFilterColors) { // move to next pixel when all colors of current pixel have been finished\n int imgXn = (imgX < (imgEndX - 1)) ? (imgX + 1) : imgStartX; \n int imgYn = imgY + (imgXn != (imgX + 1));\n\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_X/filtersPerThread) {\n fPreload[c * filtersPerThread / B_X] = filters[(c * filterPixels + (imgYn - imgLoadModPosY) * filterSize + (imgXn - imgLoadModPosX)) * numFilters];\n }\n\n if (!checkImgBounds || myImgIdx < numImages) {\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y / imgsPerThread) {\n iPreload[c * imgsPerThread / B_Y] = images[(c * imgPixels + imgYn * imgSizeX + imgXn) * imgStride];\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y / imgsPerThread) {\n iPreload[c * imgsPerThread / B_Y] = 0;\n }\n }\n } else { // move next colorCache\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_X/filtersPerThread) {\n fPreload[c * filtersPerThread / B_X] = filters[((c + oc + colorCache) * filterPixels + (imgY - imgLoadModPosY) * filterSize + (imgX - imgLoadModPosX)) * numFilters];\n }\n\n if (!checkImgBounds || myImgIdx < numImages) {\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y / imgsPerThread) {\n iPreload[c * imgsPerThread / B_Y] = images[((c + oc + colorCache) * imgPixels + imgY * imgSizeX + imgX) * imgStride];\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorCache; c += B_Y / imgsPerThread) {\n iPreload[c * imgsPerThread / B_Y] = 0;\n }\n }\n }\n\n __syncthreads();\n\n // convolution\n for (int c = 0; c < colorCache / 2; c++) {\n #pragma unroll\n for(int g = 0; g < imgsPerThread; g++) {\n #pragma unroll\n for(int f = 0; f < filtersPerThread; f++) {\n prod[f][g] += shImages[c][g * B_X + tx] * shFilters[c][ty + f * B_Y].x;\n prod[f][g] += shImages[c + colorCache / 2][g * B_X + tx] * shFilters[c][ty + f * B_Y].y;\n }\n }\n }\n __syncthreads();\n }\n }\n }\n\n // write convolution result into global memory\n if (scale) {\n #pragma unroll\n for (int g = 0; g < imgsPerThread; g++) {\n if (!checkImgBounds || myImgIdx + g * B_X < numImages) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[g * B_X + f * B_Y * numImages * numModules] = scaleTargets * targets[g * B_X + f * B_Y * numImages * numModules] + scaleOutputs * prod[f][g];\n }\n }\n }\n } else {\n // Note: reversing order of these loops saves 2 registers, but costs time\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int g = 0; g < imgsPerThread; g++) {\n if (!checkImgBounds || myImgIdx + g * B_X < numImages) {\n targets[g * B_X + f * B_Y * numImages * numModules] = scaleOutputs * prod[f][g];\n }\n }\n }\n }\n}\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages) with stride given\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModules, numFilterColors, filterPixels, numFilters) otherwise\n *\n * targets: (numFilters, numModules, numImages)\n *\n * Note: all of these convolution routines are optimized for the case when\n * the number of images (i.e. the minibatch size) is a multiple of 128.\n * Other batch sizes will work, but but I made no attempt whatsoever\n * to make them work fast.\n */\n void _filterActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int paddingStart, int moduleStride,\n int numImgColors, int numGroups,\n float scaleTargets, float scaleOutput, bool conv) {\n\n CAFFE_ENFORCE(images->ndim() == 2);\n CAFFE_ENFORCE(filters->ndim() == 2);\n CAFFE_ENFORCE(targets->ndim() == 2);\n\n int numFilterColors = numImgColors / numGroups;\n int numFilters = filters->dim32(1);\n int numModules = numModulesY * numModulesX;\n int numImages = images->dim32(1);\n int imgPixels = images->dim32(0) / numImgColors;\n int imgSizeX = imgPixels / imgSizeY;\n int filterModuleMult = conv ? 1 : numModules;\n\n CAFFE_ENFORCE(numGroups > 1 || (numImgColors > 0 && (numImgColors <= 3 || numImgColors % 4 == 0)));\n CAFFE_ENFORCE(numGroups == 1 || numFilterColors % 4 == 0);\n CAFFE_ENFORCE(numFilters % (16 * numGroups) == 0);\n CAFFE_ENFORCE(numImgColors % numGroups == 0);\n CAFFE_ENFORCE(images->dim32(0) == imgPixels * numImgColors);\n CAFFE_ENFORCE(imgSizeY * imgSizeX == imgPixels);\n int numFiltersPerGroup = numFilters / numGroups;\n\n int imgStride = images->dim32(1);\n\n int filterPixels = filters->dim32(0) / (filterModuleMult * numFilterColors);\n int filterSize = int(sqrt(filterPixels));\n CAFFE_ENFORCE(filterSize * filterSize == filterPixels);\n CAFFE_ENFORCE(filters->dim32(0) == filterModuleMult * numFilterColors * filterPixels);\n\n // These routines don't handle the case when only part of the image is visited in the convolution\n CAFFE_ENFORCE(paddingStart <= 0);\n CAFFE_ENFORCE(paddingStart + (numModulesX-1)*moduleStride + filterSize >= imgSizeX);\n CAFFE_ENFORCE(paddingStart + (numModulesY-1)*moduleStride + filterSize >= imgSizeY);\n CAFFE_ENFORCE(moduleStride <= filterSize);\n\n int imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n int filtersPerThread, threadsY = 4;\n if (numImgColors <= 3) {\n // Special kernels written for colors = 3, filters = 64 and colors = 3, filters = 48 cases.\n // The remaining cases use the old routines.\n // TODO: Modernize the remaining cases if you care about them.\n filtersPerThread = numFiltersPerGroup % 64 == 0 ? 16 : numFiltersPerGroup % 48 == 0 ? 12 : numFiltersPerGroup % 32 == 0 ? 8 : 4;\n } else {\n filtersPerThread = numFiltersPerGroup % 64 == 0 ? 16 : numFiltersPerGroup % 32 == 0 ? 8 : 4;\n threadsY = numFiltersPerGroup % 128 == 0 && numFilterColors % 8 == 0 && imgsPerThread != 4 ? 8 : 4;\n }\n int threadsX = 32;\n dim3 threads(threadsX, threadsY);\n dim3 blocks = dim3(DIVUP(numImages, threads.x * imgsPerThread), (numModules * numFilters) / (threads.y * filtersPerThread));\n\n bool checkImgBounds = numImages % (threads.x*imgsPerThread) != 0;\n bool scale = scaleTargets != 0;\n if (scaleTargets == 0) {\n targets->Resize(std::vector{numFilters * numModules, numImages});\n } else {\n CAFFE_ENFORCE(targets->dim32(0) == numFilters * numModules);\n CAFFE_ENFORCE(targets->dim32(1) == numImages);\n }\n\n cudaTextureObject_t tex_images = GetTensorTextureObject(images);\n cudaTextureObject_t tex_filters = GetTensorTextureObject(filters);\n float* images_data = images->mutable_data();\n float* filters_data = filters->mutable_data();\n float* targets_data = targets->mutable_data();\n const std::size_t images_bytes = images->nbytes();\n\n cudaStream_t stream = context->cuda_stream();\n\n checkCudaErrors(cudaDeviceSetSharedMemConfig(cudaSharedMemBankSizeEightByte)); // using wider band width\n \n // Auto-generated calling code...\n // NOTE: The calling code is set up such that if checkImgBounds is true, then imgsPerThread = 1.\n // In principle it doesn't have to be this way, and you may want to optimize for that case.\n\n if (scale == false) {\n if (checkImgBounds == false) {\n if (numFilterColors % 8 == 0) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n if (images_bytes < TEXTURE_SIZE_MAX) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, false, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, false, false > <<>>(tex_images, tex_filters, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n } else {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, false, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numFiltersPerGroup % 64 == 0) {\n if (images_bytes < TEXTURE_SIZE_MAX) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, false, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, false, false > <<>>(tex_images, tex_filters, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n } else {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, false, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 4, 8, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 4, 8, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 4, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 4, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 8, 32, 2, 16, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 8, 32, 2, 16, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 2, 16, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 2, 16, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 2, 8, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 2, 8, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 4, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 4, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 8, 32, 1, 16, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 8, 32, 1, 16, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 1, 16, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 1, 16, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 1, 8, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 1, 8, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors % 4 == 0) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 8, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 8, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 4, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 4, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 8, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 8, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 4, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 4, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 3) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_16_px_4_cc_3_tex < 4, 32, 4, 16, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_16_px_4_cc_3_tex < 4, 32, 4, 16, 3, 4, false, false > <<>>(tex_images, tex_filters, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_12_px_4_cc_3_tex < 4, 32, 4, 12, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_12_px_4_cc_3_tex < 4, 32, 4, 12, 3, 4, false, false > <<>>(tex_images, tex_filters, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 8, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 8, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 4, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 4, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 16, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 16, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 12, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 12, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 8, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 8, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 4, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 4, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 3, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 3, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 16, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 16, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 12, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 12, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 8, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 8, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 4, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 4, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 16, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 16, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 12, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 12, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 8, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 8, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 4, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 4, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 2, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 2, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 16, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 16, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 12, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 12, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 8, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 8, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 4, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 4, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 16, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 16, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 12, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 12, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 8, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 8, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 4, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 4, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 1, 4, false, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 1, 4, false, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n }\n else if (checkImgBounds == true) {\n if (numFilterColors % 8 == 0) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 8, 32, 1, 16, 8, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 8, 32, 1, 16, 8, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 8, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 8, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 8, 8, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 8, 8, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors % 4 == 0) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 3) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 3, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 3, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 3, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 3, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 3, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 3, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 3, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 3, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 2, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 2, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 2, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 2, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 2, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 2, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 2, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 2, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 1, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 1, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 1, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 1, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 1, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 1, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 1, 4, false, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 1, 4, false, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n }\n }\n else if (scale == true) {\n if (checkImgBounds == false) {\n if (numFilterColors % 8 == 0) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n if (images_bytes < TEXTURE_SIZE_MAX) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, true, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, true, false > <<>>(tex_images, tex_filters, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n } else {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, true, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numFiltersPerGroup % 64 == 0) {\n if (images_bytes < TEXTURE_SIZE_MAX) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, true, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4_tex < 4, 32, 4, 16, 4, true, false > <<>>(tex_images, tex_filters, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n } else {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, true, false >, cudaFuncCachePreferL1);\n filterActs_YxX_sparse2_preload_ty_4_tx_32_i_4_f_16_c_4 < 4, 32, 4, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 4, 8, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 4, 8, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 4, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 4, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 8, 32, 2, 16, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 8, 32, 2, 16, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 2, 16, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 2, 16, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 2, 8, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 2, 8, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 4, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 4, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 8, 32, 1, 16, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 8, 32, 1, 16, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 1, 16, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 1, 16, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2_f_vec < 4, 32, 1, 8, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2_f_vec < 4, 32, 1, 8, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors % 4 == 0) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 8, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 8, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 4, 4, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 4, 4, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 8, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 8, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 2, 4, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 2, 4, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 3) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_16_px_4_cc_3_tex < 4, 32, 4, 16, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_16_px_4_cc_3_tex < 4, 32, 4, 16, 3, 4, true, false > <<>>(tex_images, tex_filters, targets_data,numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_12_px_4_cc_3_tex < 4, 32, 4, 12, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color_preload_ty_4_tx_32_i_4_f_12_px_4_cc_3_tex < 4, 32, 4, 12, 3, 4, true, false > <<>>(tex_images, tex_filters, targets_data,numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 8, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 8, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 4, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 4, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 16, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 16, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 12, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 12, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 8, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 8, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 4, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 4, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 3, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 3, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 16, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 16, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 12, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 12, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 8, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 8, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 4, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 4, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 16, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 16, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 12, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 12, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 8, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 8, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 4, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 4, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 2, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 2, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numImages % 128 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 16, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 16, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 12, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 12, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 8, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 8, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 4, 4, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 4, 4, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 64 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 16, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 16, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 12, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 12, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 8, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 8, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 2, 4, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 2, 4, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n else if (numImages % 32 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 1, 4, true, false >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 1, 4, true, false > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n }\n else if (checkImgBounds == true) {\n if (numFilterColors % 8 == 0) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 8, 32, 1, 16, 8, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 8, 32, 1, 16, 8, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 8, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 8, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 8, 8, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 8, 8, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 8, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors % 4 == 0) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 16, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 8, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_sparse2 < 4, 32, 1, 4, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, numImgColors, numGroups, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 3) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 3, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 3, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 3, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 3, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 3, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 3, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 3, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 3, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 2, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 2, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 2, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 2, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 2, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 2, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 2, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 2, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numImages % 1 == 0) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 16, 1, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 16, 1, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 12, 1, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 12, 1, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 8, 1, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 8, 1, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n else if (numFiltersPerGroup % 1 == 0) {\n cudaFuncSetCacheConfig(filterActs_YxX_color < 4, 32, 1, 4, 1, 4, true, true >, cudaFuncCachePreferShared);\n filterActs_YxX_color < 4, 32, 1, 4, 1, 4, true, true > <<>>(images_data, filters_data, targets_data, numImages, numFilters, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, numModulesY, numModulesX, imgStride, scaleTargets, scaleOutput, conv);\n }\n }\n }\n }\n }\n\n checkCudaErrors(cudaDestroyTextureObject(tex_images));\n checkCudaErrors(cudaDestroyTextureObject(tex_filters));\n checkCudaErrors(cudaDeviceSetSharedMemConfig(cudaSharedMemBankSizeFourByte));\n\n getLastCudaError(\"filterActs: kernel execution failed\");\n}\n\nvoid convFilterActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int paddingStart, int moduleStride,\n int numImgColors, int numGroups) {\n convFilterActs(context, images, filters, targets, imgSizeY, numModulesY, numModulesX, paddingStart, moduleStride, numImgColors, numGroups, 0, 1);\n}\n\nvoid convFilterActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int paddingStart, int moduleStride,\n int numImgColors, int numGroups,\n float scaleTargets, float scaleOutput) {\n _filterActs(context, images, filters, targets, imgSizeY, numModulesY, numModulesX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput, true);\n}\n\nvoid localFilterActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int paddingStart, int moduleStride,\n int numImgColors, int numGroups) {\n localFilterActs(context, images, filters, targets, imgSizeY, numModulesY, numModulesX, paddingStart, moduleStride, numImgColors, numGroups, 0, 1);\n}\n\nvoid localFilterActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int paddingStart, int moduleStride,\n int numImgColors, int numGroups,\n float scaleTargets, float scaleOutput) {\n _filterActs(context, images, filters, targets, imgSizeY, numModulesY, numModulesX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput, false);\n}\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/img_acts.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \"../include/cudaconv2.cuh\"\n\n/*\n * Block size: 16x16.\n * blockIdx.x determines case in batches of 16*imgsPerThread.\n * blockIdx.y determines 4x4 image region in target image.\n *\n * threadIdx.x determines case.\n * threadIdx.y determines pixel.\n *\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n * filters: (numColors, filterPixels, numFilters) if conv\n * (numModulesY, numModulesX, numColors, filterPixels, numFilters) otherwise\n * targets: (numColors, imgSizeY, imgSizeX, numImages)\n *\n * Each block reconstructs one 4x4 pixels from 16*imgsPerThread cases.\n *\n * Number of filters must be divisible by 16.\n * Number of images must be divisible by 16*imgsPerThread if checkCaseBounds is false.\n * 16 * imgsPerThread must be divisible by 32.\n *\n * This version loads 32 cases at a time, so it gets full coalescing on that load.\n * It only loads 16 weights at a time, so those aren't fully coalesced.\n * This version conserves shared memory by loading 16 filters at a time rather than 32.\n */\ntemplate \n__global__ void img_acts_color(const float* hidActs, const float* filters, float* targets,\n const int numModulesY, const int numModulesX, const int numImages, const int numFilters,\n const int filterSize, const int imgSizeY, const int imgSizeX,\n const int paddingStart, const int moduleStride,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shFilters[numColors*16][16 + 1];\n __shared__ float shHidActs[16][16*imgsPerThread];\n\n const int blockCaseIdx = blockIdx.x * 16*imgsPerThread;\n const int numRegionsX = DIVUP(imgSizeX, 4);\n const int blockRegionIdx = blockIdx.y;\n const int blockRegionIdxX = blockRegionIdx % numRegionsX;\n const int blockRegionIdxY = blockRegionIdx / numRegionsX;\n const int blockRegionLeft = blockRegionIdxX * 4;\n const int blockRegionTop = blockRegionIdxY * 4;\n const int pxYInRegion = threadIdx.y / 4, pxXInRegion = threadIdx.y % 4;\n const int pxY = blockRegionTop + pxYInRegion;\n const int pxX = blockRegionLeft + pxXInRegion;\n const int pxIdx = pxY * imgSizeX + pxX;\n const bool isPxInImg = pxY < imgSizeY && pxX < imgSizeX;\n const int numModules = numModulesY * numModulesX;\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeX * imgSizeY;\n const int tidx = threadIdx.y * 16 + threadIdx.x;\n const int loadY = tidx / 32, loadX = tidx % 32;\n\n hidActs += blockCaseIdx + loadY * numImages * numModules + loadX;\n filters += threadIdx.x;\n targets += pxIdx * numImages + blockCaseIdx + threadIdx.x;\n\n\n float prod[numColors][imgsPerThread];\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[c][i] = 0;\n }\n }\n const int startY = blockRegionTop - paddingStart < filterSize ? 0\n : 1 + (blockRegionTop - paddingStart - filterSize) / moduleStride;\n const int endY = MIN(numModulesY, 1 + (blockRegionTop + 3 - paddingStart) / moduleStride);\n const int startX = blockRegionLeft - paddingStart < filterSize ? 0\n : 1 + (blockRegionLeft - paddingStart - filterSize) / moduleStride;\n const int endX = MIN(numModulesX, 1 + (blockRegionLeft + 3 - paddingStart) / moduleStride);\n\n float* shilterLoad = &shFilters[threadIdx.y][threadIdx.x];\n float* shHidActLoad = &shHidActs[loadY][loadX];\n\n for (int my = startY; my < endY; my++) {\n const int moduleTop = paddingStart + my * moduleStride;\n const int pxInModuleY = pxY - moduleTop;\n\n for (int mx = startX; mx < endX; mx++) {\n const int moduleIdx = my * numModulesX + mx;\n const int moduleLeft = paddingStart + mx * moduleStride;\n const int pxInModuleX = pxX - moduleLeft;\n\n const bool isPxInModule = pxInModuleY >= 0 && pxInModuleY < filterSize && pxInModuleX >= 0 && pxInModuleX < filterSize;\n const int pxIdxInModule = pxInModuleY * filterSize + pxInModuleX;\n\n for (int f = 0; f < numFilters; f += 16) { // multiply with 16 filters at a time\n // Now the threads split up into half-warps, and each half-warp decides if it's interested.\n const float* hLoad = &hidActs[(moduleIdx + f * numModules) * numImages];\n #pragma unroll\n for (int i = 0; i < imgsPerThread * 16; i += 32) {\n if (!checkCaseBounds || blockCaseIdx + i + loadX < numImages) {\n #pragma unroll\n for (int j = 0; j < 16; j += 8) { // load 16 rows of imgsPerThread*16 cols, 8 * 32 elements at a time.\n shHidActLoad[j * 16 * imgsPerThread + i] = hLoad[j * numModules * numImages + i];\n }\n } else {\n #pragma unroll\n for (int j = 0; j < 16; j += 8) { // load 16 rows of imgsPerThread*16 cols, 8 * 32 elements at a time.\n shHidActLoad[j * 16 * imgsPerThread + i] = 0;\n }\n }\n }\n\n if (isPxInImg && isPxInModule) {\n // This half-warp is interested, so it's going to load the weights from this module to its pixel.\n // Not fully coalesced read :(\n // But taking out this read entirely only reduces the runtime by ~2.8%, so it isn't costing me much.\n const float* fLoad = conv ? &filters[pxIdxInModule * numFilters + f]\n : &filters[(moduleIdx * numColors * filterPixels + pxIdxInModule) * numFilters + f];\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shilterLoad[c * 16 * (16 + 1)] = fLoad[c * filterPixels * numFilters];\n }\n\n\n }\n\n __syncthreads();\n // Do some actual computation\n if (isPxInImg && isPxInModule) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int w = 0; w < 16; w++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[c][i] += shFilters[threadIdx.y + c * 16][w] * shHidActs[w][threadIdx.x + i * 16];\n }\n }\n }\n }\n __syncthreads();\n }\n }\n }\n // Not fully coalesced write :(... shmem (and fully coalesced) version is actually slightly slower, though\n if (isPxInImg) {\n if (scale) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * 16 < numImages) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n targets[c * imgPixels * numImages + i * 16] = scaleTargets * targets[c * imgPixels * numImages + i * 16] + scaleOutputs * prod[c][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * 16 < numImages) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n targets[c * imgPixels * numImages + i * 16] = scaleOutputs * prod[c][i];\n }\n }\n }\n }\n }\n}\n\n/*\n * Block size: 16x16.\n * blockIdx.x determines case in batches of 16*imgsPerThread, also color in batches of colorsPerThread.\n * In essence, blockIdx.x.x = 1..numImages/(16*imgsPerThread)\n * blockIdx.x.y = 1..numImgColors/colorsPerThread\n * blockIdx.y determines 4x4 image region in target image.\n *\n * threadIdx.x determines case.\n * threadIdx.y determines pixel.\n *\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModulesY, numModulesX, numFilterColors, filterPixels, numFilters) otherwise\n * targets: (numImageColors, imgSizeY, imgSizeX, numImages)\n *\n * Each block reconstructs one 4x4 pixels from 16*imgsPerThread cases.\n *\n * numImages must be divisible by 16*imgsPerThread if checkCaseBounds is false.\n * 16 * imgsPerThread must be divisible by 32.\n * numImageColors/numGroups must be divisible by colorsPerThread.\n *\n * This version loads 32 cases at a time, so it gets full coalescing on that load.\n * It only loads 16 weights at a time, so those aren't fully coalesced.\n * This version conserves shared memory by loading 16 filters at a time rather than 32.\n *\n * To be used when there are 4-16 color channels.\n */\ntemplate \n__global__ void img_acts_mediumcolor(const float* hidActs, const float* filters, float* targets,\n const int numModulesY, const int numModulesX, const int numImages, const int numFilters,\n const int filterSize, const int imgSizeY, const int imgSizeX, const int paddingStart,\n const int moduleStride, const int numImgColors, const int numGroups,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shFilters[colorsPerThread*16][16 + 1];\n __shared__ float shHidActs[16][16*imgsPerThread];\n\n const int numImgBlocks = DIVUP(numImages,16*imgsPerThread);\n const int blockCaseIdx = (blockIdx.x % numImgBlocks) * 16*imgsPerThread;\n\n const int imgColorIdx = (blockIdx.x / numImgBlocks) * colorsPerThread; // color idx globally\n const int numFilterColors = numImgColors / numGroups;\n const int blockGroupIdx = imgColorIdx / numFilterColors;\n const int filterColorIdx = imgColorIdx % numFilterColors; // color idx within group\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockFilterIdx = blockGroupIdx * numFiltersPerGroup;\n\n const int numRegionsX = DIVUP(imgSizeX, 4);\n const int blockRegionIdx = blockIdx.y;\n const int blockRegionIdxX = blockRegionIdx % numRegionsX;\n const int blockRegionIdxY = blockRegionIdx / numRegionsX;\n const int blockRegionLeft = blockRegionIdxX * 4;\n const int blockRegionTop = blockRegionIdxY * 4;\n const int pxYInRegion = threadIdx.y / 4, pxXInRegion = threadIdx.y % 4;\n const int pxY = blockRegionTop + pxYInRegion;\n const int pxX = blockRegionLeft + pxXInRegion;\n const int pxIdx = pxY * imgSizeX + pxX;\n const bool isPxInImg = pxY < imgSizeY && pxX < imgSizeX;\n const uint numModules = numModulesY * numModulesX;\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n const int tidx = threadIdx.y * 16 + threadIdx.x;\n const int loadY = tidx / 32, loadX = tidx % 32;\n\n hidActs += blockCaseIdx + (blockFilterIdx + loadY) * numImages * numModules + loadX;\n filters += blockFilterIdx + filterColorIdx * filterPixels * numFilters + threadIdx.x;\n targets += imgColorIdx * imgPixels * numImages + pxIdx * numImages + blockCaseIdx + threadIdx.x;\n\n float prod[colorsPerThread][imgsPerThread];\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[c][i] = 0;\n }\n }\n const int startY = blockRegionTop - paddingStart < filterSize ? 0\n : 1 + (blockRegionTop - paddingStart - filterSize) / moduleStride;\n const int endY = MIN(numModulesY, 1 + (blockRegionTop + 3 - paddingStart) / moduleStride);\n const int startX = blockRegionLeft - paddingStart < filterSize ? 0\n : 1 + (blockRegionLeft - paddingStart - filterSize) / moduleStride;\n const int endX = MIN(numModulesX, 1 + (blockRegionLeft + 3 - paddingStart) / moduleStride);\n\n float* shFilterLoad = &shFilters[threadIdx.y][threadIdx.x];\n float* shHidActLoad = &shHidActs[loadY][loadX];\n\n for (int my = startY; my < endY; my++) {\n const int moduleTop = paddingStart + my * moduleStride;\n const int pxInModuleY = pxY - moduleTop;\n\n for (int mx = startX; mx < endX; mx++) {\n const int moduleIdx = my * numModulesX + mx;\n const int moduleLeft = paddingStart + mx * moduleStride;\n const int pxInModuleX = pxX - moduleLeft;\n\n const bool isPxInModule = pxInModuleY >= 0 && pxInModuleY < filterSize && pxInModuleX >= 0 && pxInModuleX < filterSize;\n const int pxIdxInModule = pxInModuleY * filterSize + pxInModuleX;\n\n for (int f = 0; f < numFiltersPerGroup; f += 16) { // multipply with 16 filters at a time\n // Now the threads split up into half-warps, and each half-warp decides if it's interested.\n const float* hLoad = &hidActs[(moduleIdx + f * numModules) * numImages];\n #pragma unroll\n for (int i = 0; i < imgsPerThread * 16; i += 32) {\n if (!checkCaseBounds || blockCaseIdx + loadX + i < numImages) {\n #pragma unroll\n for (int j = 0; j < 16; j += 8) { // load 16 rows of imgsPerThread*16 cols, 8 * 32 elements at a time.\n shHidActLoad[j * 16 * imgsPerThread + i] = hLoad[j * numModules * numImages + i];\n }\n } else {\n #pragma unroll\n for (int j = 0; j < 16; j += 8) { // load 16 rows of imgsPerThread*16 cols, 8 * 32 elements at a time.\n shHidActLoad[j * 16 * imgsPerThread + i] = 0;\n }\n }\n }\n\n if (isPxInImg && isPxInModule) {\n // This half-warp is interested, so it's going to load the weights from this module to its pixel.\n\n // Not fully coalesced read :(\n // But taking out this read entirely only reduces the runtime by ~2.8%, so it isn't costing me much.\n const float* fLoad = conv ? &filters[pxIdxInModule * numFilters + f]\n : &filters[moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInModule * numFilters + f];\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n shFilterLoad[c * 16 * (16 + 1)] = fLoad[c * filterPixels * numFilters];\n }\n }\n\n __syncthreads();\n // Do some actual computation\n if (isPxInImg && isPxInModule) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int w = 0; w < 16; w++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[c][i] += shFilters[threadIdx.y + c * 16][w] * shHidActs[w][threadIdx.x + i * 16];\n }\n }\n }\n }\n __syncthreads();\n }\n }\n }\n // Not fully coalesced write :(... shmem (and fully coalesced) version is actually slightly slower, though\n if (isPxInImg) {\n if (scale) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * 16 < numImages) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n targets[c * imgPixels * numImages + i * 16] = scaleTargets * targets[c * imgPixels * numImages + i * 16] + scaleOutputs * prod[c][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * 16 < numImages) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n targets[c * imgPixels * numImages + i * 16] = scaleOutputs * prod[c][i];\n }\n }\n }\n }\n }\n}\n\n/*\n * Block size: B_YxB_X.\n * blockIdx.x determines case in batches of B_X*imgsPerThread, also color in batches of B_Y*colorsPerThread.\n * In essence, blockIdx.x.x = 1..numImages/(B_X*imgsPerThread)\n * blockIdx.x.y = 1..numImgColors/(B_Y*colorsPerThread)\n * blockIdx.y determines image pixel in target image.\n *\n * threadIdx.x determines case.\n * threadIdx.y determines color.\n *\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModulesY, numModulesX, numFilterColors, filterPixels, numFilters) otherwise\n * targets: (numImageColors, imgSizeY, imgSizeX, numImages)\n *\n * Each block reconstructs one B_Y*colorsPerThread colors from 1 pixel from B_X*imgsPerThread cases.\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false.\n * numFiltersPerGroup must be divisible by filterCache.\n *\n * B_X * imgsPerThread must be divisible by 32.\n * numFilterColors must be divisible by B_Y*colorsPerThread.\n * B_X*B_Y must be divisible by 32.\n * filterCache must be divisible by B_X*B_Y/32\n * B_X*B_Y must be divisible by filterCache\n\n * This version loads 32 cases at a time, so it gets full coalescing on that load.\n * It only loads filterCache weights at a time, so those aren't fully coalesced (depending on size of filterCache).\n *\n * To be used when there are >= 16 color channels.\n */\ntemplate \n__global__ void conv_img_acts_manycolor(const float* hidActs, const float* filters, float* targets,\n const int numModulesY, const int numModulesX, const int numImages, const int numFilters,\n const int filterSize, const int imgSizeY, const int imgSizeX, const int paddingStart, const int moduleStride,\n const int numImgColors, const int numGroups,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shFilters[colorsPerThread*B_Y][filterCache + 1];\n __shared__ float shHidActs[filterCache][B_X*imgsPerThread];\n\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int blockCaseIdx = (blockIdx.x % numImgBlocks) * B_X*imgsPerThread;\n\n const int imgColorIdx = (blockIdx.x / numImgBlocks) * B_Y*colorsPerThread; // color idx globally\n const int numFilterColors = numImgColors / numGroups;\n const int blockGroupIdx = imgColorIdx / numFilterColors;\n const int filterColorIdx = imgColorIdx % numFilterColors; // color idx within group\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockFilterIdx = blockGroupIdx * numFiltersPerGroup;\n\n const int blockPixelIdx = blockIdx.y;\n const int blockPixelIdxX = blockPixelIdx % imgSizeX;\n const int blockPixelIdxY = blockPixelIdx / imgSizeX;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n const int hidActLoadY = tidx / 32, hidActLoadX = tidx % 32;\n const int filtersLoadY = tidx / filterCache, filtersLoadX = tidx % filterCache;\n const int numModules = numModulesY * numModulesX;\n\n hidActs += blockCaseIdx + (blockFilterIdx + hidActLoadY) * numImages * numModules + hidActLoadX;\n filters += blockFilterIdx + (filterColorIdx + filtersLoadY) * filterPixels * numFilters + filtersLoadX;\n targets += (imgColorIdx + threadIdx.y) * imgPixels * numImages + blockPixelIdx * numImages + blockCaseIdx + threadIdx.x;\n\n float prod[colorsPerThread][imgsPerThread];\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[c][i] = 0;\n }\n }\n\n const int startY = blockPixelIdxY - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxY - paddingStart - filterSize) / moduleStride;\n const int endY = MIN(numModulesY, 1 + (blockPixelIdxY - paddingStart) / moduleStride);\n const int startX = blockPixelIdxX - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxX - paddingStart - filterSize) / moduleStride;\n const int endX = MIN(numModulesX, 1 + (blockPixelIdxX - paddingStart) / moduleStride);\n\n float* shFilterLoad = &shFilters[filtersLoadY][filtersLoadX];\n float* shHidActLoad = &shHidActs[hidActLoadY][hidActLoadX];\n\n for (int my = startY; my < endY; my++) {\n const int moduleTop = paddingStart + my * moduleStride;\n const int pxInFilterY = blockPixelIdxY - moduleTop;\n\n for (int mx = startX; mx < endX; mx++) {\n const int moduleIdx = my * numModulesX + mx;\n const int moduleLeft = paddingStart + mx * moduleStride;\n const int pxInFilterX = blockPixelIdxX - moduleLeft;\n\n const int pxIdxInFilter = pxInFilterY * filterSize + pxInFilterX;\n\n for (int f = 0; f < numFiltersPerGroup; f += filterCache) { // multiply with filterCache filters at a time\n const float* hLoad = &hidActs[(moduleIdx + f * numModules) * numImages];\n #pragma unroll\n for (int i = 0; i < imgsPerThread * B_X; i += 32) {\n if (!checkCaseBounds || blockCaseIdx + hidActLoadX + i < numImages) {\n #pragma unroll\n for (int j = 0; j < filterCache; j += B_X*B_Y/32) { // load filterCache rows of imgsPerThread*B_X cols, 8 * 32 elements at a time.\n shHidActLoad[j * B_X * imgsPerThread + i] = hLoad[j * numModules * numImages + i];\n }\n } else {\n #pragma unroll\n for (int j = 0; j < filterCache; j += B_X*B_Y/32) { // load filterCache rows of imgsPerThread*B_X cols, 8 * 32 elements at a time.\n shHidActLoad[j * B_X * imgsPerThread + i] = 0;\n }\n }\n }\n const float* fLoad = conv ? &filters[pxIdxInFilter * numFilters + f]\n : &filters[moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters + f];\n #pragma unroll\n for (int i = 0; i < colorsPerThread*B_Y; i+= B_X*B_Y/filterCache) {\n if ((colorsPerThread*B_Y) % (B_X*B_Y/filterCache) == 0 || i + filtersLoadY < colorsPerThread*B_Y) {\n shFilterLoad[i * (filterCache + 1)] = fLoad[i * filterPixels * numFilters];\n }\n }\n\n __syncthreads();\n // Do some actual computation\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int w = 0; w < filterCache; w++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[c][i] += shFilters[c * B_Y + threadIdx.y][w] * shHidActs[w][threadIdx.x + i * B_X];\n }\n }\n }\n __syncthreads();\n }\n }\n }\n if (scale) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleTargets * targets[c * B_Y * imgPixels * numImages + i * B_X] + scaleOutputs * prod[c][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleOutputs * prod[c][i];\n }\n }\n }\n }\n}\n\n\n/*\n * Block size: B_YxB_X.\n * blockIdx.x determines case in batches of B_X*imgsPerThread, also color in batches of B_Y*colorsPerThread.\n * In essence, blockIdx.x.x = 1..numImages/(B_X*imgsPerThread)\n * blockIdx.x.y = 1..numImgColors/(B_Y*colorsPerThread)\n * blockIdx.y determines image pixel in target image.\n *\n * threadIdx.x determines case.\n * threadIdx.y determines color.\n *\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModulesY, numModulesX, numFilterColors, filterPixels, numFilters) otherwise\n * targets: (numImageColors, imgSizeY, imgSizeX, numImages)\n *\n * Each block reconstructs one B_Y*colorsPerThread colors from 1 pixel from B_X*imgsPerThread cases.\n *\n * numImages must be divisible by B_X*imgsPerThread if checkCaseBounds is false.\n * numFiltersPerGroup must be divisible by filterCacheF.\n *\n * numFilterColors must be divisible by B_Y*colorsPerThread.\n * B_X*B_Y must be divisible by filterCacheF\n * filterCacheF must be divisible by filterCacheH\n *\n * This version loads 32 cases at a time, so it gets full coalescing on that load.\n * It only loads filterCacheF weights at a time, so those aren't fully coalesced (depending on size of filterCacheF).\n *\n * To be used when there are >= 16 color channels.\n */\ntemplate \n__global__ void conv_img_acts_manycolor_kepler(const float* hidActs, const float* filters, float* targets,\n const int numModulesY, const int numModulesX, const int numImages, const int numFilters,\n const int filterSize, const int imgSizeY, const int imgSizeX, const int paddingStart, const int moduleStride,\n const int numImgColors, const int numGroups,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shFilters[colorsPerThread*B_Y][filterCacheF];\n __shared__ float shHidActs[filterCacheH][B_X*imgsPerThread];\n\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int blockCaseIdx = (blockIdx.x % numImgBlocks) * B_X*imgsPerThread;\n\n const int imgColorIdx = (blockIdx.x / numImgBlocks) * B_Y*colorsPerThread; // color idx globally\n const int numFilterColors = numImgColors / numGroups;\n const int blockGroupIdx = imgColorIdx / numFilterColors;\n const int filterColorIdx = imgColorIdx % numFilterColors; // color idx within group\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockFilterIdx = blockGroupIdx * numFiltersPerGroup;\n\n const int blockPixelIdx = blockIdx.y;\n const int blockPixelIdxX = blockPixelIdx % imgSizeX;\n const int blockPixelIdxY = blockPixelIdx / imgSizeX;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n const int hidActLoadY = threadIdx.y, hidActLoadX = threadIdx.x;\n //const int hidActLoadY = tidx / (B_X*imgsPerThread), hidActLoadX = tidx % (B_X*imgsPerThread);\n const int filtersLoadY = tidx / filterCacheF, filtersLoadX = tidx % filterCacheF;\n // nvcc is behaving idiotically again, these useless declarations save registers\n //const int outputY = threadIdx.y, outputX = threadIdx.x;\n //const int ty = threadIdx.y, tx = threadIdx.x;\n const int numModules = numModulesY * numModulesX;\n\n hidActs += blockCaseIdx + (blockFilterIdx + hidActLoadY) * numImages * numModules + hidActLoadX;\n filters += blockFilterIdx + (filterColorIdx + filtersLoadY) * filterPixels * numFilters + filtersLoadX;\n targets += (imgColorIdx + threadIdx.y) * imgPixels * numImages + blockPixelIdx * numImages + blockCaseIdx + threadIdx.x;\n\n float prod[colorsPerThread][imgsPerThread];\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[c][i] = 0;\n }\n }\n\n const int startY = blockPixelIdxY - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxY - paddingStart - filterSize) / moduleStride;\n const int endY = min(numModulesY, 1 + (blockPixelIdxY - paddingStart) / moduleStride);\n const int startX = blockPixelIdxX - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxX - paddingStart - filterSize) / moduleStride;\n const int endX = min(numModulesX, 1 + (blockPixelIdxX - paddingStart) / moduleStride);\n\n float* shFilterLoad = &shFilters[filtersLoadY][filtersLoadX];\n float* shHidActLoad = &shHidActs[hidActLoadY][hidActLoadX];\n //const bool noFLoop = filterCacheF == filterCacheH;\n for (int my = startY; my < endY; my++) {\n const int moduleTop = paddingStart + my * moduleStride;\n const int pxInFilterY = blockPixelIdxY - moduleTop;\n\n for (int mx = startX; mx < endX; mx++) {\n const int moduleIdx = my * numModulesX + mx;\n const int moduleLeft = paddingStart + mx * moduleStride;\n const int pxInFilterX = blockPixelIdxX - moduleLeft;\n\n const int pxIdxInFilter = pxInFilterY * filterSize + pxInFilterX;\n\n for (int f = 0; f < numFiltersPerGroup; f += filterCacheF) { // multiply with filterCacheF filters at a time\n const float* fLoad = conv ? &filters[pxIdxInFilter * numFilters + f]\n : &filters[moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters + f];\n #pragma unroll\n for (int i = 0; i < colorsPerThread*B_Y; i+= B_X*B_Y/filterCacheF) {\n if ((colorsPerThread*B_Y) % (B_X*B_Y/filterCacheF) == 0 || i + filtersLoadY < colorsPerThread*B_Y) {\n shFilterLoad[i * filterCacheF] = fLoad[i * filterPixels * numFilters];\n }\n }\n //#pragma unroll\n\n for (int fh = f; fh < f + filterCacheF; fh += filterCacheH) {\n //conv_img_acts_manycolor_dummy_fhLoop(hidActs, shHidActLoad, shHidActs, shFilters, moduleIdx, numImages, hidActLoadY, hidActLoadX, blockCaseIdx, numModules, f, fh, prod);\n\n const float* hLoad = &hidActs[(moduleIdx + fh * numModules) * numImages];\n\n #pragma unroll\n for (int j = 0; j < filterCacheH; j += B_Y) {\n if (filterCacheH % B_Y == 0 || hidActLoadY + j < filterCacheH) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread*B_X; i += B_X) {\n if (!checkCaseBounds || blockCaseIdx + hidActLoadX + i < numImages) {\n shHidActLoad[j * B_X * imgsPerThread + i] = hLoad[j * numModules * numImages + i];\n } else {\n shHidActLoad[j * B_X * imgsPerThread + i] = 0;\n }\n }\n }\n }\n\n __syncthreads();\n\n // Do some actual computation\n // Using these variables causes register usage to go from 161 --> 123.\n // But nonetheless, the high-register version is faster.\n //const float* shF = &shFilters[threadIdx.y][fh-f];\n //const float* const shF2 = &shFilters[threadIdx.y][fh];\n //const float* shH = &shHidActs[0][threadIdx.x];\n #pragma unroll\n for (int w = 0; w < filterCacheH; w++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n prod[c][i] += shFilters[c * B_Y + threadIdx.y][fh-f + w] * shHidActs[w][threadIdx.x + i * B_X];\n\n }\n }\n }\n __syncthreads();\n\n }\n }\n }\n }\n if (scale) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleTargets * targets[c * B_Y * imgPixels * numImages + i * B_X] + scaleOutputs * prod[c][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || blockCaseIdx + threadIdx.x + i * B_X < numImages) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleOutputs * prod[c][i];\n }\n }\n }\n }\n}\n\n/*\n * New Titan-optimized stuff.\n */\n\n__device__ __forceinline__ void conv_img_acts_manycolor_preload_ty_8_tx_32_c_8_ff_32_fh_16_setCoords(const int my, const int mx, const int numModulesX,\n const int paddingStart, const int moduleStride, const int blockPixelIdxY, const int blockPixelIdxX, const int filterSize, int &moduleIdx, int &pxIdxInFilter) {\n const int moduleTop = paddingStart + my * moduleStride;\n const int pxInFilterY = blockPixelIdxY - moduleTop;\n\n moduleIdx = my * numModulesX + mx; // out\n const int moduleLeft = paddingStart + mx * moduleStride;\n const int pxInFilterX = blockPixelIdxX - moduleLeft;\n\n pxIdxInFilter = pxInFilterY * filterSize + pxInFilterX; // out\n}\n\n#define IA_PRELOAD_LOOP(w,offset) _Pragma(\"unroll\") \\\nfor (int i = 0; i < imgsPerThread; i++) { \\\n _Pragma(\"unroll\") \\\n for (int c = 0; c < colorsPerThread; c++) { \\\n prod[c][i] += shFilters[c * B_Y + threadIdx.y][(w)+(offset)] * shHidActs[w][threadIdx.x * imgsPerThread + i]; \\\n } \\\n} \\\n\n/*\n * Same loop as above but inverted.\n */\n#define IA_PRELOAD_LOOP2(w,offset) _Pragma(\"unroll\") \\\nfor (int c = 0; c < colorsPerThread; c++) { \\\n _Pragma(\"unroll\") \\\n for (int i = 0; i < imgsPerThread; i++) { \\\n prod[c][i] += shFilters[c * B_Y + threadIdx.y][(w)+(offset)] * shHidActs[w][threadIdx.x * imgsPerThread + i]; \\\n } \\\n} \\\n\n#define IA_PRELOAD_LOOP3(i,offset) _Pragma(\"unroll\") \\\nfor (int w = 0; w < filterCacheH; w++) { \\\n _Pragma(\"unroll\") \\\n for (int c = 0; c < colorsPerThread; c++) { \\\n prod[c][i] += shFilters[c * B_Y + threadIdx.y][(w)+(offset)] * shHidActs[w][threadIdx.x * imgsPerThread + i]; \\\n } \\\n} \\\n\n#define IA_PRELOAD_W(z) wPreload[z] = fLoad[(z) * B_X*B_Y/filterCacheF * filterPixels * numFilters];\n#define IA_PRELOAD_W_TX(z) wPreload[z] = tex1Dfetch(filters, filtersLoadOffset + (z) * B_X*B_Y/filterCacheF * filterPixels * numFilters);\n#define IA_PRELOAD_H(y,x) if (!checkCaseBounds || myCaseIdx + (x) * B_X < numImages) { \\\n hPreload[y][x] = hLoad[(y) * B_Y * numModules * numImages + (x) * B_X]; \\\n}\n#define IA_PRELOAD_H_TX(y,x) if (!checkCaseBounds || myCaseIdx + (x) * B_X < numImages) { \\\n hPreload[y][x] = tex1Dfetch(hidActs, hidActsLoadOffset + (y) * B_Y * numModules * numImages + (x) * B_X); \\\n}\n\ntemplate \n__global__ void\n__launch_bounds__(256, 2) // 256 threads per block, 2 blocks per multiprocessor\n // These launch bounds ensure 25% occupancy (128 registers used)\n // as oppposed to 13% (130 registers) achieved by defaults.\nconv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex(cudaTextureObject_t hidActs, cudaTextureObject_t filters, float* targets,\n const int numModulesY, const int numModulesX, const int numImages, const int numFilters,\n const int filterSize, const int imgSizeY, const int imgSizeX, const int paddingStart, const int moduleStride,\n const int numImgColors, const int numGroups,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shFilters[colorsPerThread*B_Y][filterCacheF];\n __shared__ float shHidActs[filterCacheH][B_X*imgsPerThread];\n\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int blockCaseIdx = (blockIdx.x % numImgBlocks) * B_X*imgsPerThread;\n const int myCaseIdx = blockCaseIdx + threadIdx.x;\n\n const int imgColorIdx = (blockIdx.x / numImgBlocks) * B_Y*colorsPerThread; // color idx globally\n const int numFilterColors = numImgColors / numGroups;\n const int blockGroupIdx = imgColorIdx / numFilterColors;\n const int filterColorIdx = imgColorIdx % numFilterColors; // color idx within group\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockFilterIdx = blockGroupIdx * numFiltersPerGroup;\n\n const int blockPixelIdx = blockIdx.y;\n const int blockPixelIdxX = blockPixelIdx % imgSizeX;\n const int blockPixelIdxY = blockPixelIdx / imgSizeX;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n// const int hidActLoadY = threadIdx.y % B_Y, hidActLoadX = threadIdx.x % B_X;\n //const int hidActLoadY = tidx / (B_X*imgsPerThread), hidActLoadX = tidx % (B_X*imgsPerThread);\n const int filtersLoadY = tidx / filterCacheF, filtersLoadX = tidx % filterCacheF;\n // nvcc is behaving idiotically again, these useless declarations save registers\n //const int outputY = threadIdx.y, outputX = threadIdx.x;\n //const int ty = threadIdx.y, tx = threadIdx.x;\n const int numModules = numModulesY * numModulesX;\n const int hidActsOffset = (blockFilterIdx + threadIdx.y) * numImages * numModules + myCaseIdx;\n const int filtersOffset = blockFilterIdx + (filterColorIdx + filtersLoadY) * filterPixels * numFilters + filtersLoadX;\n// hidActs += (blockFilterIdx + threadIdx.y) * numImages * numModules + myCaseIdx;\n// filters += blockFilterIdx + (filterColorIdx + filtersLoadY) * filterPixels * numFilters + filtersLoadX;\n targets += (imgColorIdx + threadIdx.y) * imgPixels * numImages + blockPixelIdx * numImages + myCaseIdx;\n\n float prod[colorsPerThread][imgsPerThread];\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[c][i] = 0;\n }\n }\n\n const int startY = blockPixelIdxY - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxY - paddingStart - filterSize) / moduleStride;\n const int endY = min(numModulesY, 1 + (blockPixelIdxY - paddingStart) / moduleStride);\n const int startX = blockPixelIdxX - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxX - paddingStart - filterSize) / moduleStride;\n const int endX = min(numModulesX, 1 + (blockPixelIdxX - paddingStart) / moduleStride);\n\n float* shFilterLoad = &shFilters[filtersLoadY][filtersLoadX];\n float* shHidActLoad = &shHidActs[threadIdx.y][threadIdx.x * imgsPerThread];\n //const bool noFLoop = filterCacheF == filterCacheH;\n\n /*\n * Initial preload\n */\n float hPreload[filterCacheH/B_Y][imgsPerThread]; // [2][4]\n float wPreload[filterCacheF*colorsPerThread/B_X]; // [8]\n\n int moduleIdx, pxIdxInFilter;\n conv_img_acts_manycolor_preload_ty_8_tx_32_c_8_ff_32_fh_16_setCoords(startY, startX, numModulesX, paddingStart, moduleStride, blockPixelIdxY,\n blockPixelIdxX, filterSize, moduleIdx, pxIdxInFilter);\n// const float* fLoad = conv ? &filters[pxIdxInFilter * numFilters + 0]\n// : &filters[moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters + 0];\n int filtersLoadOffset = filtersOffset + (conv ? pxIdxInFilter * numFilters + 0\n : moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters);\n #pragma unroll\n for (int i = 0; i < colorsPerThread*B_Y; i+= B_X*B_Y/filterCacheF) {\n if ((colorsPerThread*B_Y) % (B_X*B_Y/filterCacheF) == 0 || i + filtersLoadY < colorsPerThread*B_Y) {\n wPreload[i * filterCacheF/(B_X*B_Y)] = tex1Dfetch(filters, filtersLoadOffset + i * filterPixels * numFilters);\n }\n }\n\n// const float* hLoad = &hidActs[(moduleIdx + 0 * numModules) * numImages];\n int hidActsLoadOffset = hidActsOffset + (moduleIdx + 0 * numModules) * numImages;\n #pragma unroll\n for (int j = 0; j < filterCacheH; j += B_Y) {\n if (filterCacheH % B_Y == 0 || threadIdx.y + j < filterCacheH) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n hPreload[j/B_Y][i] = tex1Dfetch(hidActs, hidActsLoadOffset + j * numModules * numImages + i * B_X);\n }\n }\n }\n }\n\n for (int my = startY; my < endY; my++) {\n const int moduleTop = paddingStart + my * moduleStride;\n const int pxInFilterY = blockPixelIdxY - moduleTop;\n\n for (int mx = startX; mx < endX; mx++) {\n moduleIdx = my * numModulesX + mx;\n const int moduleLeft = paddingStart + mx * moduleStride;\n const int pxInFilterX = blockPixelIdxX - moduleLeft;\n\n pxIdxInFilter = pxInFilterY * filterSize + pxInFilterX;\n int myNext = my, mxNext = mx, moduleIdxNext, pxIdxInFilterNext;\n const bool lastModule = my == endY - 1 && mx == endX - 1;\n if (!lastModule) {\n mxNext = mx + 1 == endX ? startX : mx + 1;\n myNext = my + (mx + 1 == endX);\n }\n conv_img_acts_manycolor_preload_ty_8_tx_32_c_8_ff_32_fh_16_setCoords(myNext, mxNext, numModulesX, paddingStart, moduleStride, blockPixelIdxY,\n blockPixelIdxX, filterSize, moduleIdxNext, pxIdxInFilterNext);\n for (int f = 0; f < numFiltersPerGroup; f += filterCacheF) { // multiply with filterCacheF filters at a time\n #pragma unroll\n for (int i = 0; i < colorsPerThread*B_Y; i+= B_X*B_Y/filterCacheF) {\n if ((colorsPerThread*B_Y) % (B_X*B_Y/filterCacheF) == 0 || i + filtersLoadY < colorsPerThread*B_Y) {\n shFilterLoad[i * filterCacheF] = wPreload[i * filterCacheF/(B_X*B_Y)];\n }\n }\n\n filtersLoadOffset = filtersOffset + (conv ? pxIdxInFilter * numFilters + f + filterCacheF\n : moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters + f + filterCacheF);\n if (f == numFiltersPerGroup - filterCacheF) {\n filtersLoadOffset = filtersOffset + (conv ? pxIdxInFilterNext * numFilters\n : moduleIdxNext * numFilterColors * filterPixels * numFilters + pxIdxInFilterNext * numFilters);\n }\n\n #pragma unroll\n for (int j = 0; j < filterCacheH; j += B_Y) {\n if (filterCacheH % B_Y == 0 || threadIdx.y + j < filterCacheH) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n // NOTE: bank conflicts here!\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n shHidActLoad[j * B_X * imgsPerThread + i] = hPreload[j/B_Y][i];\n }\n }\n }\n }\n\n __syncthreads();\n\n hidActsLoadOffset = hidActsOffset + (moduleIdx + (f + filterCacheH) * numModules) * numImages;\n\n #pragma unroll\n for (int z = 0; z < 4; ++z) {\n IA_PRELOAD_LOOP(z,0);\n IA_PRELOAD_W_TX(z);\n }\n\n #pragma unroll\n for (int z = 4; z < 12; ++z) {\n IA_PRELOAD_LOOP(z,0);\n IA_PRELOAD_H_TX((z-4)/4,z%4);\n }\n\n #pragma unroll\n for (int z = 12; z < 16; ++z) {\n IA_PRELOAD_LOOP(z,0);\n }\n\n __syncthreads();\n\n #pragma unroll\n for (int j = 0; j < filterCacheH; j += B_Y) {\n if (filterCacheH % B_Y == 0 || threadIdx.y + j < filterCacheH) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n shHidActLoad[j * B_X * imgsPerThread + i] = hPreload[j/B_Y][i];\n }\n }\n }\n }\n\n __syncthreads();\n\n hidActsLoadOffset = hidActsOffset + (moduleIdx + (f + filterCacheF) * numModules) * numImages;\n if (f == numFiltersPerGroup - filterCacheF) {\n hidActsLoadOffset = hidActsOffset + moduleIdxNext * numImages;\n }\n\n #pragma unroll\n for (int z = 0; z < 4; ++z) {\n IA_PRELOAD_LOOP(z,filterCacheH);\n IA_PRELOAD_W_TX(z+4);\n }\n\n #pragma unroll\n for (int z = 4; z < 12; ++z) {\n IA_PRELOAD_LOOP(z,filterCacheH);\n IA_PRELOAD_H_TX((z-4)/4, z%4);\n }\n\n #pragma unroll\n for (int z = 12; z < 16; ++z) {\n IA_PRELOAD_LOOP(z,filterCacheH);\n }\n\n __syncthreads();\n }\n }\n }\n if (scale) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleTargets * targets[c * B_Y * imgPixels * numImages + i * B_X] + scaleOutputs * prod[c][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleOutputs * prod[c][i];\n }\n }\n }\n }\n}\n\n\ntemplate \n__global__ void\n//__launch_bounds__(128, 3) // 128 threads per block, 3 blocks per multiprocessor\nconv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16(cudaTextureObject_t hidActs, cudaTextureObject_t filters, float* targets,\n const int numModulesY, const int numModulesX, const int numImages, const int numFilters,\n const int filterSize, const int imgSizeY, const int imgSizeX, const int paddingStart, const int moduleStride,\n const int numImgColors, const int numGroups,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shFilters[colorsPerThread*B_Y][filterCacheF];\n __shared__ float shHidActs[filterCacheH][B_X*imgsPerThread];\n\n const int numImgBlocks = DIVUP(numImages,B_X*imgsPerThread);\n const int blockCaseIdx = (blockIdx.x % numImgBlocks) * B_X*imgsPerThread;\n const int myCaseIdx = blockCaseIdx + threadIdx.x;\n\n const int imgColorIdx = (blockIdx.x / numImgBlocks) * B_Y*colorsPerThread; // color idx globally\n const int numFilterColors = numImgColors / numGroups;\n const int blockGroupIdx = imgColorIdx / numFilterColors;\n const int filterColorIdx = imgColorIdx % numFilterColors; // color idx within group\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockFilterIdx = blockGroupIdx * numFiltersPerGroup;\n\n const int blockPixelIdx = blockIdx.y;\n const int blockPixelIdxX = blockPixelIdx % imgSizeX;\n const int blockPixelIdxY = blockPixelIdx / imgSizeX;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n const int tidx = threadIdx.y * B_X + threadIdx.x;\n// const int hidActLoadY = threadIdx.y % B_Y, hidActLoadX = threadIdx.x % B_X;\n //const int hidActLoadY = tidx / (B_X*imgsPerThread), hidActLoadX = tidx % (B_X*imgsPerThread);\n const int filtersLoadY = tidx / filterCacheF, filtersLoadX = tidx % filterCacheF;\n // nvcc is behaving idiotically again, these useless declarations save registers\n //const int outputY = threadIdx.y, outputX = threadIdx.x;\n //const int ty = threadIdx.y, tx = threadIdx.x;\n const int numModules = numModulesY * numModulesX;\n\n const int hidActsOffset = (blockFilterIdx + threadIdx.y) * numImages * numModules + myCaseIdx;\n const int filtersOffset = blockFilterIdx + (filterColorIdx + filtersLoadY) * filterPixels * numFilters + filtersLoadX;\n\n// hidActs += (blockFilterIdx + threadIdx.y) * numImages * numModules + myCaseIdx;\n// filters += blockFilterIdx + (filterColorIdx + filtersLoadY) * filterPixels * numFilters + filtersLoadX;\n targets += (imgColorIdx + threadIdx.y) * imgPixels * numImages + blockPixelIdx * numImages + myCaseIdx;\n\n float prod[colorsPerThread][imgsPerThread];\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[c][i] = 0;\n }\n }\n\n const int startY = blockPixelIdxY - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxY - paddingStart - filterSize) / moduleStride;\n const int endY = min(numModulesY, 1 + (blockPixelIdxY - paddingStart) / moduleStride);\n const int startX = blockPixelIdxX - paddingStart < filterSize ? 0\n : 1 + (blockPixelIdxX - paddingStart - filterSize) / moduleStride;\n const int endX = min(numModulesX, 1 + (blockPixelIdxX - paddingStart) / moduleStride);\n\n float* shFilterLoad = &shFilters[filtersLoadY][filtersLoadX];\n float* shHidActLoad = &shHidActs[threadIdx.y][threadIdx.x * imgsPerThread];\n //const bool noFLoop = filterCacheF == filterCacheH;\n\n /*\n * Initial preload\n */\n float hPreload[filterCacheH/B_Y][imgsPerThread]; // [4][4]\n float wPreload[filterCacheF*colorsPerThread/B_X]; // [6]\n\n int moduleIdx, pxIdxInFilter;\n conv_img_acts_manycolor_preload_ty_8_tx_32_c_8_ff_32_fh_16_setCoords(startY, startX, numModulesX, paddingStart, moduleStride, blockPixelIdxY,\n blockPixelIdxX, filterSize, moduleIdx, pxIdxInFilter);\n// const float* fLoad = conv ? &filters[pxIdxInFilter * numFilters + 0]\n// : &filters[moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters + 0];\n int filtersLoadOffset = filtersOffset + (conv ? pxIdxInFilter * numFilters\n : moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters);\n #pragma unroll\n for (int i = 0; i < colorsPerThread*B_Y; i+= B_X*B_Y/filterCacheF) {\n if ((colorsPerThread*B_Y) % (B_X*B_Y/filterCacheF) == 0 || i + filtersLoadY < colorsPerThread*B_Y) {\n wPreload[i * filterCacheF/(B_X*B_Y)] = tex1Dfetch(filters, filtersLoadOffset + i * filterPixels * numFilters);\n }\n }\n\n// const float* hLoad = &hidActs[moduleIdx * numImages];\n int hidActsLoadOffset = hidActsOffset + moduleIdx * numImages;\n #pragma unroll\n for (int j = 0; j < filterCacheH; j += B_Y) {\n if (filterCacheH % B_Y == 0 || threadIdx.y + j < filterCacheH) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n hPreload[j/B_Y][i] = tex1Dfetch(hidActs, hidActsLoadOffset + j * numModules * numImages + i * B_X);\n }\n }\n }\n }\n\n for (int my = startY; my < endY; my++) {\n const int moduleTop = paddingStart + my * moduleStride;\n const int pxInFilterY = blockPixelIdxY - moduleTop;\n\n for (int mx = startX; mx < endX; mx++) {\n moduleIdx = my * numModulesX + mx;\n const int moduleLeft = paddingStart + mx * moduleStride;\n const int pxInFilterX = blockPixelIdxX - moduleLeft;\n\n pxIdxInFilter = pxInFilterY * filterSize + pxInFilterX;\n int myNext = my, mxNext = mx, moduleIdxNext, pxIdxInFilterNext;\n const bool lastModule = my == endY - 1 && mx == endX - 1;\n if (!lastModule) {\n mxNext = mx + 1 == endX ? startX : mx + 1;\n myNext = my + (mx + 1 == endX);\n }\n conv_img_acts_manycolor_preload_ty_8_tx_32_c_8_ff_32_fh_16_setCoords(myNext, mxNext, numModulesX, paddingStart, moduleStride, blockPixelIdxY,\n blockPixelIdxX, filterSize, moduleIdxNext, pxIdxInFilterNext);\n for (int f = 0; f < numFiltersPerGroup; f += filterCacheF) { // multiply with filterCacheF filters at a time\n #pragma unroll\n for (int i = 0; i < colorsPerThread*B_Y; i+= B_X*B_Y/filterCacheF) {\n if ((colorsPerThread*B_Y) % (B_X*B_Y/filterCacheF) == 0 || i + filtersLoadY < colorsPerThread*B_Y) {\n shFilterLoad[i * filterCacheF] = wPreload[i * filterCacheF/(B_X*B_Y)];\n }\n }\n\n filtersLoadOffset = filtersOffset + (conv ? pxIdxInFilter * numFilters + f + filterCacheF\n : moduleIdx * numFilterColors * filterPixels * numFilters + pxIdxInFilter * numFilters + f + filterCacheF);\n if (f == numFiltersPerGroup - filterCacheF) {\n filtersLoadOffset = filtersOffset + (conv ? pxIdxInFilterNext * numFilters\n : moduleIdxNext * numFilterColors * filterPixels * numFilters + pxIdxInFilterNext * numFilters);\n }\n\n #pragma unroll\n for (int j = 0; j < filterCacheH; j += B_Y) {\n if (filterCacheH % B_Y == 0 || threadIdx.y + j < filterCacheH) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n // NOTE: bank conflicts here!\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n shHidActLoad[j * B_X * imgsPerThread + i] = hPreload[j/B_Y][i];\n }\n }\n }\n }\n hidActsLoadOffset = hidActsOffset + (moduleIdx + (f + filterCacheF) * numModules) * numImages;\n if (f == numFiltersPerGroup - filterCacheF) {\n hidActsLoadOffset = hidActsOffset + moduleIdxNext * numImages;\n }\n\n __syncthreads();\n\n // It seems that there is no point explicitly interleaving loads\n // and computations because the scheduler does that anyway.\n\n IA_PRELOAD_LOOP2(0,0);\n IA_PRELOAD_LOOP2(1,0);\n IA_PRELOAD_LOOP2(2,0);\n IA_PRELOAD_LOOP2(3,0);\n IA_PRELOAD_LOOP2(4,0);\n IA_PRELOAD_LOOP2(5,0);\n IA_PRELOAD_LOOP2(6,0);\n IA_PRELOAD_LOOP2(7,0);\n IA_PRELOAD_LOOP2(8,0);\n IA_PRELOAD_LOOP2(9,0);\n IA_PRELOAD_LOOP2(10,0);\n IA_PRELOAD_LOOP2(11,0);\n IA_PRELOAD_LOOP2(12,0);\n IA_PRELOAD_LOOP2(13,0);\n IA_PRELOAD_LOOP2(14,0);\n IA_PRELOAD_LOOP2(15,0);\n\n IA_PRELOAD_W_TX(0);\n IA_PRELOAD_W_TX(1);\n IA_PRELOAD_W_TX(2);\n IA_PRELOAD_W_TX(3);\n IA_PRELOAD_W_TX(4);\n IA_PRELOAD_W_TX(5);\n\n IA_PRELOAD_H_TX(0,0);\n IA_PRELOAD_H_TX(0,1);\n IA_PRELOAD_H_TX(0,2);\n IA_PRELOAD_H_TX(0,3);\n IA_PRELOAD_H_TX(1,0);\n IA_PRELOAD_H_TX(1,1);\n IA_PRELOAD_H_TX(1,2);\n IA_PRELOAD_H_TX(1,3);\n IA_PRELOAD_H_TX(2,0);\n IA_PRELOAD_H_TX(2,1);\n IA_PRELOAD_H_TX(2,2);\n IA_PRELOAD_H_TX(2,3);\n IA_PRELOAD_H_TX(3,0);\n IA_PRELOAD_H_TX(3,1);\n IA_PRELOAD_H_TX(3,2);\n IA_PRELOAD_H_TX(3,3);\n\n __syncthreads();\n }\n }\n }\n if (scale) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleTargets * targets[c * B_Y * imgPixels * numImages + i * B_X] + scaleOutputs * prod[c][i];\n }\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int i = 0; i < imgsPerThread; i++) {\n if (!checkCaseBounds || myCaseIdx + i * B_X < numImages) {\n targets[c * B_Y * imgPixels * numImages + i * B_X] = scaleOutputs * prod[c][i];\n }\n }\n }\n }\n}\n\n/*\n * hidActs: (numFilters, numModules, numImages)\n * filters: (numFilterColors, filterPixels, numFilters) if conv\n * (numModules, numFilterColors, filterPixels, numFilters) otherwise\n * targets: (overSample, numImgColors, imgPixels, numImages)\n *\n * Note: all of these convolution routines are optimized for the case when\n * the number of images (i.e. the minibatch size) is a multiple of 128.\n * Other batch sizes will work, but but I made no attempt whatsoever\n * to make them work fast.\n */\nvoid _imgActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int imgSizeX, int numModulesY, int paddingStart, int moduleStride, int numImgColors, int numGroups,\n float scaleTargets, float scaleOutput, bool conv) {\n CAFFE_ENFORCE(hidActs->ndim() == 2);\n CAFFE_ENFORCE(filters->ndim() == 2);\n CAFFE_ENFORCE(targets->ndim() == 2);\n\n int numFilterColors = numImgColors / numGroups;\n int numImages = hidActs->dim32(1);\n int numFilters = filters->dim32(1);\n int numModules = hidActs->dim32(0) / numFilters;\n int filterModuleMult = conv ? 1 : numModules;\n int filterPixels = filters->dim32(0) / (filterModuleMult * numFilterColors);\n int filterSize = sqrt(filterPixels);\n int imgPixels = imgSizeY * imgSizeX;\n int numModulesX = numModules / numModulesY;\n\n CAFFE_ENFORCE(numImgColors % numGroups == 0);\n CAFFE_ENFORCE(numFilters % (16*numGroups) == 0); // TODO: insisting on 32 filters due to bug in calling code below. fix that.\n CAFFE_ENFORCE(numGroups > 1 || (numImgColors > 0 && (numImgColors <= 3 || numImgColors % 2 == 0)));\n CAFFE_ENFORCE(numGroups == 1 || numFilterColors % 4 == 0);\n\n CAFFE_ENFORCE(filterPixels == filterSize * filterSize);\n CAFFE_ENFORCE(hidActs->dim32(0) == numModules * numFilters);\n CAFFE_ENFORCE(filters->dim32(0) == filterModuleMult * numFilterColors * filterPixels);\n CAFFE_ENFORCE(numModules == numModulesY * numModulesX);\n\n // These routines don't handle the case when only part of the image is visited in the convolution\n CAFFE_ENFORCE(paddingStart <= 0);\n CAFFE_ENFORCE(paddingStart + (numModulesX-1)*moduleStride + filterSize >= imgSizeX);\n CAFFE_ENFORCE(paddingStart + (numModulesY-1)*moduleStride + filterSize >= imgSizeY);\n CAFFE_ENFORCE(moduleStride <= filterSize);\n\n dim3 blocks;\n dim3 threads;\n int colorsPerThread, imgsPerThread;\n if (numFilterColors % 8 == 0) {\n threads = dim3(32, numFilterColors % 64 == 0 ? 8 : 4);\n colorsPerThread = numFilterColors % 64 == 0 ? 8\n : numFilterColors % 48 == 0 ? 12\n : numFilterColors % 32 == 0 ? 8\n : numFilterColors % 16 == 0 ? 4\n : 2;\n imgsPerThread = numImages % 128 == 0 ? 4 : numImages % 64 == 0 ? 2 : 1;\n CAFFE_ENFORCE(numFilterColors % (threads.y * colorsPerThread) == 0);\n\n blocks = dim3(DIVUP(numImages, threads.x*imgsPerThread) * (numImgColors/(threads.y*colorsPerThread)), imgPixels);\n // NOTE: the case when channels % 32 == 0 but channels % 48 != 0 and channels % 64 != 0 has not been optimized!!\n } else if (numFilterColors > 3) {\n // NOTE: THIS CASE HAS NOT BEEN OPTIMIZED FOR KEPLER!!\n imgsPerThread = numImages % 128 == 0 ? 8 : numImages % 64 == 0 ? 4 : 2;\n threads = dim3(16, 16);\n colorsPerThread = numFilterColors % 4 == 0 ? 4 : 2;\n blocks = dim3(DIVUP(numImages,threads.x*imgsPerThread) * (numImgColors / colorsPerThread), DIVUP(imgSizeY,4) * DIVUP(imgSizeX,4));\n } else {\n // NOTE: THIS CASE HAS NOT BEEN OPTIMIZED FOR KEPLER!!\n imgsPerThread = numImages % 128 == 0 ? 8 : numImages % 64 == 0 ? 4 : 2;\n threads = dim3(16, 16);\n blocks = dim3(DIVUP(numImages,threads.x*imgsPerThread), DIVUP(imgSizeY,4) * DIVUP(imgSizeX,4));\n }\n bool checkCaseBounds = numImages % (threads.x * imgsPerThread) != 0;\n\n if (scaleTargets == 0) { // do not scale or use targets matrix\n targets->Resize(std::vector{numImgColors*imgPixels, numImages});\n } else {\n CAFFE_ENFORCE(targets->dim32(0) == numImgColors * imgPixels);\n CAFFE_ENFORCE(targets->dim32(1) == numImages);\n }\n const bool scale = scaleTargets != 0;\n\n cudaTextureObject_t tex_hidacts = GetTensorTextureObject(hidActs);\n cudaTextureObject_t tex_filters = GetTensorTextureObject(filters);\n float* hidacts_data = hidActs->mutable_data();\n float* filters_data = filters->mutable_data();\n float* targets_data = targets->mutable_data();\n\n cudaStream_t stream = context->cuda_stream();\n// cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n// conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, false, false, true ><<>>(\n// tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize,\n// imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n\n //return;\n// printf(\"conv: %d\\n\", conv);\n// printf(\"scale: %d\\n\", scale);\n// printf(\"checkCaseBounds: %d\\n\", checkCaseBounds);\n// printf(\"numFilterColors: %d\\n\", numFilterColors);\n// printf(\"numImages: %d\\n\", numImages);\n// cudaStream_t stream = NVMatrix::getDefaultStream();\n\n if (conv == true) {\n if (scale == false) {\n if (checkCaseBounds == false) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, false, false, true ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, false, false, true ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 8, 4, false, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 8, 4, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 4, 4, false, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 4, 4, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, false, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, false, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 3, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 3, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 3, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 3, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 1, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 1, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 1, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 1, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, false, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, false, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n else if (checkCaseBounds == true) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, false, true, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, false, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, false, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, false, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n }\n else if (scale == true) {\n if (checkCaseBounds == false) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, true, false, true ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, true, false, true ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 8, 4, true, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 8, 4, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 4, 4, true, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 4, 4, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, true, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, true, false, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 3, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 3, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 3, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 3, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 1, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 8, 1, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 1, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 4, 1, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, true, false, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, true, false, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n else if (checkCaseBounds == true) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, true, true >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, true, true, true >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, true, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, true, true, true >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, true, true, true ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n }\n }\n else if (conv == false) {\n if (scale == false) {\n if (checkCaseBounds == false) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, false, false, false ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, false, false, false ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 8, 4, false, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 8, 4, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 4, 4, false, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 4, 4, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, false, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, false, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 3, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 3, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 3, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 3, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 1, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 1, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 1, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 1, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, false, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, false, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n else if (checkCaseBounds == true) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, false, true, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, false, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, false, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, false, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, false, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n }\n else if (scale == true) {\n if (checkCaseBounds == false) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_8_tx_32_c_8_ff_32_fh_16_tex< 8, 32, 4, 8, 32, 16, true, false, false ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 32, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 4, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 2, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_preloadfh_ty_4_tx_32_c_12_ff_16_fh_16< 4, 32, 4, 12, 16, 16, true, false, false ><<>>(tex_hidacts, tex_filters, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 12, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 32, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 32, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 4, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 4, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 4, 2, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 2, 2, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 8, 4, true, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 8, 4, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 4, 4, true, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 4, 4, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, true, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, true, false, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 3, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 3, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 3, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 3, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 128 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 8, 1, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 8, 1, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 64 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 4, 1, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 4, 1, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 32 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n else if (numImages % 16 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, true, false, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, true, false, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n else if (checkCaseBounds == true) {\n if (numFilterColors % 8 == 0) {\n if (numFilterColors % 64 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 32, 16, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 8, 32, 1, 8, 16, 16, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 12, 16, 16, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFilters % 32 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 32, 16, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n else if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 8, 16, 16, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 4, 16, 16, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors % 8 == 0) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, true, false >, cudaFuncCachePreferShared);\n conv_img_acts_manycolor_kepler < 4, 32, 1, 2, 16, 16, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors > 3) {\n if (numFilterColors == 4) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_mediumcolor < 2, 4, true, true, false >, cudaFuncCachePreferShared);\n img_acts_mediumcolor < 2, 4, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 3, true, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 3, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 2) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 2, true, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 2, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors == 1) {\n if (numFilters % 16 == 0) {\n if (numImages % 1 == 0) {\n cudaFuncSetCacheConfig(img_acts_color < 2, 1, true, true, false >, cudaFuncCachePreferShared);\n img_acts_color < 2, 1, true, true, false ><<>>(hidacts_data, filters_data, targets_data, numModulesY, numModulesX, numImages, numFilters, filterSize, imgSizeY, imgSizeX, paddingStart, moduleStride, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n }\n }\n\n checkCudaErrors(cudaDestroyTextureObject(tex_hidacts));\n checkCudaErrors(cudaDestroyTextureObject(tex_filters));\n\n getLastCudaError(\"imgActs: kernel execution failed\");\n}\n\n\nvoid convImgActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int imgSizeX, int numModulesY, int paddingStart, int moduleStride, int numImgColors, int numGroups) {\n _imgActs(context, hidActs, filters, targets, imgSizeY, imgSizeX, numModulesY, paddingStart, moduleStride, numImgColors, numGroups, 0, 1, true);\n}\n\nvoid convImgActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int imgSizeX, int numModulesY, int paddingStart, int moduleStride, int numImgColors, int numGroups,\n float scaleTargets, float scaleOutput) {\n _imgActs(context, hidActs, filters, targets, imgSizeY, imgSizeX, numModulesY, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput, true);\n}\n\nvoid localImgActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int imgSizeX, int numModulesY, int paddingStart, int moduleStride, int numImgColors, int numGroups) {\n _imgActs(context, hidActs, filters, targets, imgSizeY, imgSizeX, numModulesY, paddingStart, moduleStride, numImgColors, numGroups, 0, 1, false);\n}\n\nvoid localImgActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* filters, caffe2::TensorCUDA* targets,\n int imgSizeY, int imgSizeX, int numModulesY, int paddingStart, int moduleStride, int numImgColors, int numGroups,\n float scaleTargets, float scaleOutput) {\n _imgActs(context, hidActs, filters, targets, imgSizeY, imgSizeX, numModulesY, paddingStart, moduleStride, numImgColors, numGroups, scaleTargets, scaleOutput, false);\n}\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconv3/src/weight_acts.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n\n#include \"../include/cudaconv2.cuh\"\n\n#define LO16(x) ((x) & 0x0000FFFF)\n#define HI16(x) ((x) >> 16)\n\n#define WA_LOOP(r) _Pragma(\"unroll\") \\\nfor (int c = 0; c < colorsPerThread; c++) { \\\n _Pragma(\"unroll\") \\\n for (int f = 0; f < filtersPerThread; f++) { \\\n prod[f][c] += shImages[threadIdx.y + c * B_Y][(r)] * shHidActs[threadIdx.x + f * B_X][(r)]; \\\n } \\\n}\n\n#define WA_LOOP2(r) _Pragma(\"unroll\") \\\nfor (int f = 0; f < filtersPerThread; f++) { \\\n _Pragma(\"unroll\") \\\n for (int c = 0; c < colorsPerThread; c++) { \\\n prod[f][c] += shImages[threadIdx.y + c * B_Y][(r)] * shHidActs[threadIdx.x + f * B_X][(r)]; \\\n } \\\n}\n\n#define WA_IMLOAD(r) imPreload[r] = im[(r) * B_X * B_Y / preloadCases * imgPixels * imgStride];\n#define WA_IMLOAD_TX(r) imPreload[r] = tex1Dfetch(images, imgOffset2 + (r) * B_X * B_Y / preloadCases * imgPixels * imgStride);\n#define WA_HALOAD(r) haPreload[r] = ha[(r) * B_X * B_Y / preloadCases * numImages * numModules];\n#define WA_HALOAD_TX(r) haPreload[r] = tex1Dfetch(hidActs, hidActsOffset2 + (r) * B_X * B_Y / preloadCases * numImages * numModules);\n\n__device__ __forceinline__ void conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16_setCoords(\n const int my, const int mx, const int paddingStart, const int numModulesX, const int moduleStride,\n const int blockPixelY, const int blockPixelX, const int imgSizeX,\n const int imgStride, int& pixIdx, int& m) {\n const int imgLoadModPosY = paddingStart + my * moduleStride;\n const int imgLoadModPosX = paddingStart + mx * moduleStride;\n const int pxY = imgLoadModPosY + blockPixelY; // pixel x,y coords in image\n const int pxX = imgLoadModPosX + blockPixelX;\n pixIdx = (pxY * imgSizeX + pxX) * imgStride; // pixel idx in image\n m = my * numModulesX + mx;\n}\n\n/*\n * Each block computes weight gradients for B_Y * pixelsPerThread pixels and B_X filters\n * threadIdx.x determines filter\n * threadIdx.y determines pixel in filter\n *\n * blockIdx.x determines filter batch of B_X * filtersPerThread, module batch of partialSum\n * blockIdx.y determines pixel batch of B_Y * pixelsPerThread\n *\n * Number of filters must be divisible by B_X * filtersPerThread\n * Number of images (cases) should be divisible by preloadCases if checkCaseBounds is false.\n *\n * images: (numColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numColors, filterPixels, numFilters)\n *\n * B_Y * B_X should be divisible by preloadCases.\n * preloadCases one of 16, 32.\n * B_X one of 4, 8, 16, 32\n * B_Y arbitrary (satisfying divisibility constraints)\n * numModules must be divisible by partialSum\n * pixelsPerThread must be divisible by pixelCache\n *\n * After adding pixelsPerThread, register usage went from 20 to 23 (when pixelsPerThread = 1)...\n * so the compiler is messing up here somehow. It's unable to optimize that case away.\n */\ntemplate \n__global__ void conv_weight_acts_c_kepler(float* images, float* hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int partialSum,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImages[pixelCache * B_Y * numColors][preloadCases]; // preload preloadCases cases of B_Y * pixelsPerThread pixels\n __shared__ float shHidActs[B_X * filtersPerThread][preloadCases + 1]; // preload preloadCases cases of B_X hidActs\n\n const int tidx = B_X * threadIdx.y + threadIdx.x;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int filterBlocksPerModule = numFilters / (B_X*filtersPerThread);\n const int outputModuleIdx = blockIdx.x / filterBlocksPerModule;\n const int moduleIdx = partialSum * outputModuleIdx;\n const int blockFilterIdx = B_X * filtersPerThread* (blockIdx.x % filterBlocksPerModule);\n\n// const int moduleStride = (imgSize - filterSize + 1) / numModulesX;\n const int numModules = numModulesY * numModulesX;\n\n const int blockPixelOffset = blockIdx.y * B_Y * pixelsPerThread;\n\n images += loadX;\n hidActs += blockFilterIdx * numImages * numModules\n + loadY * numImages * numModules\n + loadX;\n\n targets += (outputModuleIdx * numFilters) * filterPixels * numColors\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + threadIdx.y * numFilters + threadIdx.x;\n\n float prod[numColors][pixelsPerThread][filtersPerThread];\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[c][p][f] = 0;\n }\n }\n }\n\n __shared__ int pxIdxes[B_Y*pixelsPerThread];\n //__shared__ bool isPxInImage[B_Y*pixelsPerThread];\n for (int m = moduleIdx; m < moduleIdx + partialSum; m++) {\n\n __syncthreads();\n if (tidx < B_Y * pixelsPerThread) {\n const int imgLoadModPosY = paddingStart + (m / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (m % numModulesX) * moduleStride;\n int pxY = (imgLoadModPosY + (blockPixelOffset + tidx) / filterSize);\n int pxX = (imgLoadModPosX + (blockPixelOffset + tidx) % filterSize);\n int pixIdx = (pxY * imgSizeX + pxX) * imgStride;\n pxIdxes[tidx] = pxY >= 0 && pxY < imgSizeY && pxX >= 0 && pxX < imgSizeX ? pixIdx : -1;\n //isPxInImage[tidx] = ;\n }\n __syncthreads();\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n if (/*loadY < B_X*filtersPerThread &&*/ (!checkCaseBounds || caseIdx + loadX < numImages)) {\n #pragma unroll\n for (int y = 0; y < B_X*filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_X*filtersPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_X*filtersPerThread) {\n shHidActs[loadY+y][loadX]= hidActs[caseIdx + y * numImages * numModules + m * numImages];\n }\n }\n }\n #pragma unroll\n for (int pp = 0; pp < pixelsPerThread; pp += pixelCache) {\n //if (loadY < B_Y * pixelCache) { // This condition is not necessary for correctness, but it speeds things a bit\n /*\n * As long as B_Y * B_X is divisible by preloadCases this will loop the right\n * number of times.\n *\n * This will load some imgGrads from filter pixels that don't exit (it'll set those to 0),\n * but the code does not produce any output for those pixels (see last lines).\n */\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y * pixelCache) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y * pixelCache) {\n const int pxIdx = pp * B_Y + loadY + y; // pixel idx in filter\n\n if (pxIdx + blockPixelOffset < filterPixels && (!checkCaseBounds || caseIdx + loadX < numImages)) {\n const int pixIdx = pxIdxes[pxIdx];//(pxY * imgSizeX + pxX) * imgStride;\n\n if (pixIdx >= 0) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = images[caseIdx + c * imgPixels * imgStride + pixIdx];\n }\n } else {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = 0;\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX]= 0;\n }\n }\n }\n }\n //}\n\n\n __syncthreads();\n\n #pragma unroll\n for (int i = 0; i < preloadCases; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int p = 0; p < pixelCache; p++) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n prod[c][pp + p][f] += shImages[threadIdx.y + p * B_Y + c * pixelCache * B_Y][i] * shHidActs[threadIdx.x + f * B_X][i];\n }\n }\n }\n }\n\n __syncthreads();\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleTargets * targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n } else {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n }\n}\n\n/*\n * Each block computes weight gradients for 1 pixel, B_Y * colorsPerThread colors and B_X * filtersPerThread filters\n * threadIdx.x determines filter\n * threadIdx.y determines color\n *\n * blockIdx.x determines filter batch of B_X * filtersPerThread, module batch of partialSum\n * blockIdx.y determines color batch of B_Y * colorsPerThread\n * blockIdx.z determines pixel in filter\n * NOTE: blockIdx.z is limited to values < 2^16. This means that this routine will\n * fail for filters >= 256*256. I'm assuming I won't ever use such large filters.\n\n * images: (numImgColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numFilterColors, filterPixels, numFilters)\n\n * B_X * B_Y must be divisible by preloadCases\n */\ntemplate \n__global__ void conv_weight_acts_mc_mf_kepler(float* images, float* hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int numImgColors, const int numGroups, const int partialSum,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImages[colorsPerThread * B_Y][preloadCases]; // preload preloadCases cases\n __shared__ float shHidActs[filtersPerThread * B_X][preloadCases + 1]; // preload preloadCases cases of B_X hidacts\n\n const int tidx = B_X * threadIdx.y + threadIdx.x;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X * filtersPerThread);\n const int outputModuleIdx = blockIdx.x / numFilterBlocks;\n const int moduleIdx = partialSum * outputModuleIdx;\n const int blockFilterIdx = filtersPerThread * B_X * (blockIdx.x % numFilterBlocks);\n const int numModules = numModulesY * numModulesX;\n\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n const int numFilterColors = numImgColors / numGroups;\n\n const int blockPixelOffset = blockIdx.z; // pixel idx in filter\n const int blockPixelY = blockPixelOffset / filterSize, blockPixelX = blockPixelOffset % filterSize;\n const int blockFilterColorIdx = blockIdx.y * B_Y * colorsPerThread;\n const int imgColorIdx = blockFilterColorIdx + blockGroupIdx * numFilterColors;\n\n images += (imgColorIdx + loadY) * imgPixels * imgStride + loadX;\n\n hidActs +=\n blockFilterIdx * numImages * numModules\n + loadY * numImages * numModules\n + loadX;\n\n targets += outputModuleIdx * numFilters * filterPixels * numFilterColors\n + (blockFilterColorIdx + threadIdx.y) * filterPixels * numFilters\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + threadIdx.x;\n //if (blockIdx.x != 0 || blockIdx.y != 0 || blockIdx.z != 0) return;\n float* shHidActLoad = &shHidActs[loadY][loadX];\n float* shImgLoad = &shImages[loadY][loadX];\n float prod[colorsPerThread][filtersPerThread];\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[c][f] = 0;\n }\n }\n\n for (int m = moduleIdx; m < moduleIdx + partialSum; m++) {\n const int imgLoadModPosY = paddingStart + (m / numModulesX) * moduleStride;\n const int imgLoadModPosX = paddingStart + (m % numModulesX) * moduleStride;\n const int pxY = imgLoadModPosY + blockPixelY; // pixel x,y coords in image\n const int pxX = imgLoadModPosX + blockPixelX;\n const int pixIdx = (pxY * imgSizeX + pxX) * imgStride; // pixel idx in image\n if (pxY >= 0 && pxY < imgSizeY && pxX >= 0 && pxX < imgSizeX) {\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n // Checking this condition actually makes things faster ... :/\n // So I've removed the !checkCaseBounds flag and just check it all the time.\n if (caseIdx + loadX < numImages) {\n /*\n * As long as B_Y * B_X is divisible by preloadCases this will loop the right\n * number of times.\n *\n * This will load some images from filter pixels that don't exist (it'll set those to 0),\n * but the code does not produce any output for those pixels (see last lines).\n */\n if (loadY < B_Y * colorsPerThread) {\n #pragma unroll\n for (int y = 0; y < B_Y * colorsPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y*colorsPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y*colorsPerThread) {\n shImgLoad[(y) * preloadCases] = images[caseIdx + y * imgPixels * imgStride + pixIdx];\n }\n }\n }\n\n if (loadY < B_X * filtersPerThread) {\n #pragma unroll\n for (int y = 0; y < B_X * filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_X * filtersPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_X * filtersPerThread) {\n shHidActLoad[y * (preloadCases + 1)] = hidActs[caseIdx + y * numImages * numModules + m * numImages];\n }\n }\n }\n } else {\n #pragma unroll\n for (int y = 0; y < B_Y * colorsPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y*colorsPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y*colorsPerThread) {\n shImgLoad[(y) * preloadCases] = 0;\n }\n }\n #pragma unroll\n for (int y = 0; y < B_X * filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_X * filtersPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_X * filtersPerThread) {\n shHidActLoad[y * (preloadCases + 1)] = 0;\n }\n }\n }\n\n __syncthreads();\n #pragma unroll\n for (int i = 0; i < preloadCases; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[c][f] += shImages[threadIdx.y + c * B_Y][i] * shHidActs[threadIdx.x + f * B_X][i];\n }\n }\n }\n __syncthreads();\n }\n }\n }\n if (scale) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleTargets * targets[c * B_Y * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[c][f];\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[c][f];\n }\n }\n }\n}\n\n\n/*\n * Each block computes weight gradients for 1 pixel, B_Y * colorsPerThread colors and B_X * filtersPerThread filters\n * threadIdx.x determines filter\n * threadIdx.y determines color\n *\n * blockIdx.x determines filter batch of B_X * filtersPerThread, module batch of partialSum\n * blockIdx.y determines color batch of B_Y * colorsPerThread\n * blockIdx.z determines pixel in filter\n * NOTE: blockIdx.z is limited to values < 2^16. This means that this routine will\n * fail for filters >= 256*256. I'm assuming I won't ever use such large filters.\n\n * images: (numImgColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numFilterColors, filterPixels, numFilters)\n\n * B_X * B_Y must be divisible by preloadCases\n */\ntemplate \n__global__ void conv_weight_acts_mc_mf_kepler_sw(float* images, float* hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int numImgColors, const int numGroups, const int sumWidth,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImages[colorsPerThread * B_Y][preloadCases]; // preload preloadCases cases\n __shared__ float shHidActs[filtersPerThread * B_X][preloadCases + 1]; // preload preloadCases cases of B_X hidacts\n\n const int tidx = B_X * threadIdx.y + threadIdx.x;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X * filtersPerThread);\n const int blockModuleChunkIdx = blockIdx.x / numFilterBlocks;\n\n const int numModuleChunksX = DIVUP(numModulesX, sumWidth);\n// const int numModuleChunksY = DIVUP(numModulesY, sumWidth);\n\n const int blockModuleChunkX = blockModuleChunkIdx % numModuleChunksX;\n const int blockModuleChunkY = blockModuleChunkIdx / numModuleChunksX;\n\n const int blockModuleStartX = blockModuleChunkX * sumWidth;\n const int blockModuleStartY = blockModuleChunkY * sumWidth;\n\n const int blockFilterIdx = filtersPerThread * B_X * (blockIdx.x % numFilterBlocks);\n const int numModules = numModulesY * numModulesX;\n\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n const int numFilterColors = numImgColors / numGroups;\n\n const int blockPixelOffset = blockIdx.z; // pixel idx in filter\n const int blockPixelY = blockPixelOffset / filterSize, blockPixelX = blockPixelOffset % filterSize;\n const int blockFilterColorIdx = blockIdx.y * B_Y * colorsPerThread;\n const int imgColorIdx = blockFilterColorIdx + blockGroupIdx * numFilterColors;\n\n images += (imgColorIdx + loadY) * imgPixels * imgStride + loadX;\n\n hidActs +=\n blockFilterIdx * numImages * numModules\n + loadY * numImages * numModules\n + loadX;\n\n targets += blockModuleChunkIdx * numFilters * filterPixels * numFilterColors\n + (blockFilterColorIdx + threadIdx.y) * filterPixels * numFilters\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + threadIdx.x;\n //if (blockIdx.x != 0 || blockIdx.y != 0 || blockIdx.z != 0) return;\n\n const int mStartX = max(blockModuleStartX, DIVUP(-blockPixelX - paddingStart, moduleStride));\n const int mStartY = max(blockModuleStartY, DIVUP(-blockPixelY - paddingStart, moduleStride));\n const int mEndX = min(numModulesX, min(blockModuleStartX + sumWidth, DIVUP(imgSizeX - blockPixelX - paddingStart, moduleStride)));\n const int mEndY = min(numModulesY, min(blockModuleStartY + sumWidth, DIVUP(imgSizeY - blockPixelY - paddingStart, moduleStride)));\n\n// if (mStartY == mEndY || mStartX == mEndX) {\n// return;\n// }\n\n float* shHidActLoad = &shHidActs[loadY][loadX];\n float* shImgLoad = &shImages[loadY][loadX];\n float prod[colorsPerThread][filtersPerThread];\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[c][f] = 0;\n }\n }\n\n /*\n * Note; iterating this way is about 1% slower and uses a few more registers than iterating\n * over the modules linearly. But it's consistent with the preload routines,\n * so I'm using it.\n */\n for (int my = mStartY; my < mEndY; my++) {\n const int imgLoadModPosY = paddingStart + my * moduleStride;\n const int pxY = imgLoadModPosY + blockPixelY; // pixel x,y coords in image\n for (int mx = mStartX; mx < mEndX; mx++) {\n const int m = my * numModulesX + mx;\n const int imgLoadModPosX = paddingStart + mx * moduleStride;\n const int pxX = imgLoadModPosX + blockPixelX;\n const int pixIdx = (pxY * imgSizeX + pxX) * imgStride; // pixel idx in image\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n // Checking this condition actually makes things faster ... :/\n // So I've removed the !checkCaseBounds flag and just check it all the time.\n if (caseIdx + loadX < numImages) {\n /*\n * As long as B_Y * B_X is divisible by preloadCases this will loop the right\n * number of times.\n *\n * This will load some images from filter pixels that don't exist (it'll set those to 0),\n * but the code does not produce any output for those pixels (see last lines).\n */\n if (loadY < B_Y * colorsPerThread) {\n #pragma unroll\n for (int y = 0; y < B_Y * colorsPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y*colorsPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y*colorsPerThread) {\n shImgLoad[(y) * preloadCases] = images[caseIdx + y * imgPixels * imgStride + pixIdx];\n }\n }\n }\n\n if (loadY < B_X * filtersPerThread) {\n #pragma unroll\n for (int y = 0; y < B_X * filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_X * filtersPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_X * filtersPerThread) {\n shHidActLoad[y * (preloadCases + 1)] = hidActs[caseIdx + y * numImages * numModules + m * numImages];\n }\n }\n }\n } else {\n #pragma unroll\n for (int y = 0; y < B_Y * colorsPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y*colorsPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y*colorsPerThread) {\n shImgLoad[(y) * preloadCases] = 0;\n }\n }\n #pragma unroll\n for (int y = 0; y < B_X * filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_X * filtersPerThread) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_X * filtersPerThread) {\n shHidActLoad[y * (preloadCases + 1)] = 0;\n }\n }\n }\n\n __syncthreads();\n #pragma unroll\n for (int i = 0; i < preloadCases; i++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[c][f] += shImages[threadIdx.y + c * B_Y][i] * shHidActs[threadIdx.x + f * B_X][i];\n }\n }\n }\n __syncthreads();\n }\n\n }\n }\n if (scale) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleTargets * targets[c * B_Y * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[c][f];\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[c][f];\n }\n }\n }\n}\n\n\n/*\n * Each block computes weight gradients for B_Y * pixelsPerThread pixels and B_X filters\n * threadIdx.x determines filter\n * threadIdx.y determines pixel in filter\n *\n * blockIdx.x determines filter batch of B_X * filtersPerThread, module batch of partialSum\n * blockIdx.y determines pixel batch of B_Y * pixelsPerThread\n *\n * Number of filters must be divisible by B_X * filtersPerThread\n * Number of images (cases) should be divisible by preloadCases if checkCaseBounds is false.\n *\n * images: (numColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numColors, filterPixels, numFilters)\n *\n * B_Y * B_X should be divisible by preloadCases.\n * preloadCases one of 16, 32.\n * B_X one of 4, 8, 16, 32\n * B_Y arbitrary (satisfying divisibility constraints)\n * numModules must be divisible by partialSum\n * pixelsPerThread must be divisible by pixelCache\n *\n * After adding pixelsPerThread, register usage went from 20 to 23 (when pixelsPerThread = 1)...\n * so the compiler is messing up here somehow. It's unable to optimize that case away.\n */\ntemplate \n__global__ void conv_weight_acts_c_kepler_sw(float* images, float* hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int sumWidth,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImages[pixelCache * B_Y * numColors][preloadCases]; // preload preloadCases cases of B_Y * pixelsPerThread pixels\n __shared__ float shHidActs[B_X * filtersPerThread][preloadCases + 1]; // preload preloadCases cases of B_X hidActs\n\n const int tidx = B_X * threadIdx.y + threadIdx.x;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X*filtersPerThread);\n\n const int blockModuleChunkIdx = blockIdx.x / numFilterBlocks;\n\n const int numModuleChunksX = DIVUP(numModulesX, sumWidth);\n// const int numModuleChunksY = DIVUP(numModulesY, sumWidth);\n\n const int blockModuleChunkX = blockModuleChunkIdx % numModuleChunksX;\n const int blockModuleChunkY = blockModuleChunkIdx / numModuleChunksX;\n\n const int blockModuleStartX = blockModuleChunkX * sumWidth;\n const int blockModuleStartY = blockModuleChunkY * sumWidth;\n\n const int blockFilterIdx = B_X * filtersPerThread* (blockIdx.x % numFilterBlocks);\n\n// const int moduleStride = (imgSize - filterSize + 1) / numModulesX;\n const int numModules = numModulesY * numModulesX;\n\n const int blockPixelOffset = blockIdx.y * B_Y * pixelsPerThread;\n\n images += loadX;\n hidActs += blockFilterIdx * numImages * numModules\n// + loadY * numImages * numModules\n + loadX;\n\n targets += (blockModuleChunkIdx * numFilters) * filterPixels * numColors\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + threadIdx.y * numFilters + threadIdx.x;\n\n //float* shImgLoad = &shImages[loadY][loadX];\n //float* shHidActLoad = &shHidActs[loadY][loadX];\n\n float prod[numColors][pixelsPerThread][filtersPerThread];\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[c][p][f] = 0;\n }\n }\n }\n const int mStartX = blockModuleStartX;\n const int mStartY = blockModuleStartY;\n const int mEndX = min(numModulesX, blockModuleStartX + sumWidth);\n const int mEndY = min(numModulesY, blockModuleStartY + sumWidth);\n\n// if (mStartY == mEndY || mStartX == mEndX) {\n// return;\n// }\n\n const int fYOff = (blockPixelOffset + tidx) / filterSize;\n const int fXOff = (blockPixelOffset + tidx) % filterSize;\n __shared__ int pxIdxes[B_Y*pixelsPerThread];\n for (int my = mStartY; my < mEndY; my++) {\n const int imgLoadModPosY = paddingStart + my * moduleStride;\n for (int mx = mStartX; mx < mEndX; mx++) {\n const int m = my * numModulesX + mx;\n\n __syncthreads();\n const int imgLoadModPosX = paddingStart + mx * moduleStride;\n if (tidx < B_Y * pixelsPerThread) {\n// const int imgLoadModPosY = paddingStart + my * moduleStride;\n// const int imgLoadModPosX = paddingStart + mx * moduleStride;\n int pxY = (imgLoadModPosY + fYOff);\n int pxX = (imgLoadModPosX + fXOff);\n int pixIdx = (pxY * imgSizeX + pxX) * imgStride;\n pxIdxes[tidx] = pxY >= 0 && pxY < imgSizeY && pxX >= 0 && pxX < imgSizeX ? pixIdx : -1;\n }\n __syncthreads();\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n if (/*loadY < B_X*filtersPerThread &&*/ (!checkCaseBounds || caseIdx + loadX < numImages)) {\n #pragma unroll\n for (int y = 0; y < B_X*filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n const int fIdx = ((loadY + y) % filtersPerThread) * B_X + (loadY + y) / filtersPerThread;\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_X*filtersPerThread) % (B_X * B_Y / preloadCases) == 0 || loadY+y < B_X*filtersPerThread) {\n shHidActs[loadY+y][loadX]= hidActs[caseIdx + fIdx * numImages * numModules + m * numImages];\n }\n }\n } else {\n #pragma unroll\n for (int y = 0; y < B_X*filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n // const int fIdx = ((loadY + y) % filtersPerThread) * B_X + (loadY + y) / filtersPerThread;\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_X*filtersPerThread) % (B_X * B_Y / preloadCases) == 0 || loadY+y < B_X*filtersPerThread) {\n shHidActs[loadY+y][loadX] = 0;\n }\n }\n }\n #pragma unroll\n for (int pp = 0; pp < pixelsPerThread; pp += pixelCache) {\n //if (loadY < B_Y * pixelCache) { // This condition is not necessary for correctness, but it speeds things a bit\n /*\n * As long as B_Y * B_X is divisible by preloadCases this will loop the right\n * number of times.\n *\n * This will load some imgGrads from filter pixels that don't exit (it'll set those to 0),\n * but the code does not produce any output for those pixels (see last lines).\n */\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y * pixelCache) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y * pixelCache) {\n const int pxIdx = pp * B_Y + loadY + y; // pixel idx in filter\n\n if (pxIdx + blockPixelOffset < filterPixels && (!checkCaseBounds || caseIdx + loadX < numImages)) {\n const int pixIdx = pxIdxes[pxIdx];//(pxY * imgSizeX + pxX) * imgStride;\n\n if (pixIdx >= 0) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = images[caseIdx + c * imgPixels * imgStride + pixIdx];\n }\n } else {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = 0;\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX]= 0;\n }\n }\n }\n }\n //}\n\n __syncthreads();\n\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int i = 0; i < preloadCases; i++) {\n #pragma unroll\n for (int p = 0; p < pixelCache; p++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[c][pp + p][f] += shImages[threadIdx.y + p * B_Y + c * pixelCache * B_Y][i] * shHidActs[threadIdx.x * filtersPerThread + f][i];\n }\n }\n }\n }\n\n __syncthreads();\n }\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleTargets * targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n } else {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n }\n}\n\n\n#define WA_C3_LOOP(pp, c) _Pragma(\"unroll\") \\\nfor (int i = 0; i < preloadCases; i++) { \\\n _Pragma(\"unroll\") \\\n for (int p = 0; p < pixelCache; p++) { \\\n _Pragma(\"unroll\") \\\n for (int f = 0; f < filtersPerThread; f++) { \\\n prod[c][(pp) + p][f] += shImages[threadIdx.y + p * B_Y + (c) * pixelCache * B_Y][i] * shHidActs[threadIdx.x * filtersPerThread + f][i]; \\\n } \\\n } \\\n}\n\n#define WA_C3_LOOP2(pp) _Pragma(\"unroll\") \\\nfor (int p = 0; p < pixelCache; p++) { \\\n _Pragma(\"unroll\") \\\n for (int i = 0; i < preloadCases; i++) { \\\n _Pragma(\"unroll\") \\\n for (int f = 0; f < filtersPerThread; f++) { \\\n _Pragma(\"unroll\") \\\n for (int c = 0; c < 3; ++c) { \\\n prod[c][(pp) + p][f] += shImages[threadIdx.y + p * B_Y + (c) * pixelCache * B_Y][i] * shHidActs[threadIdx.x * filtersPerThread + f][i]; \\\n } \\\n } \\\n } \\\n}\n\n#define WA_3_FIDX(y) (((loadY + (y)*B_X*B_Y/preloadCases) % filtersPerThread) * B_X + (loadY + (y)*B_X*B_Y/preloadCases) / filtersPerThread)\n\n\n/*\n * Each block computes weight gradients for B_Y * pixelsPerThread pixels and B_X filters\n * threadIdx.x determines filter\n * threadIdx.y determines pixel in filter\n *\n * blockIdx.x determines filter batch of B_X * filtersPerThread, module batch of partialSum\n * blockIdx.y determines pixel batch of B_Y * pixelsPerThread\n *\n * Number of filters must be divisible by B_X * filtersPerThread\n * Number of images (cases) should be divisible by preloadCases if checkCaseBounds is false.\n *\n * images: (numColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numColors, filterPixels, numFilters)\n *\n * B_Y * B_X should be divisible by preloadCases.\n * preloadCases one of 16, 32.\n * B_X one of 4, 8, 16, 32\n * B_Y arbitrary (satisfying divisibility constraints)\n * numModules must be divisible by partialSum\n * pixelsPerThread must be divisible by pixelCache\n *\n * After adding pixelsPerThread, register usage went from 20 to 23 (when pixelsPerThread = 1)...\n * so the compiler is messing up here somehow. It's unable to optimize that case away.\n */\ntemplate \n//__launch_bounds__(256,2)\n__global__ void conv_weight_acts_c_preload_pc_2_pt_2_f_4_r_32_c_3(cudaTextureObject_t images, cudaTextureObject_t hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int sumWidth,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImages[pixelCache * B_Y * numColors][preloadCases]; // preload preloadCases cases of B_Y * pixelsPerThread pixels\n __shared__ float shHidActs[B_X * filtersPerThread][preloadCases + 1]; // preload preloadCases cases of B_X hidActs\n\n const int tidx = B_X * threadIdx.y + threadIdx.x;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X*filtersPerThread);\n\n const int blockModuleChunkIdx = blockIdx.x / numFilterBlocks;\n\n const int numModuleChunksX = DIVUP(numModulesX, sumWidth);\n// const int numModuleChunksY = DIVUP(numModulesY, sumWidth);\n\n const int blockModuleChunkX = blockModuleChunkIdx % numModuleChunksX;\n const int blockModuleChunkY = blockModuleChunkIdx / numModuleChunksX;\n\n const int blockModuleStartX = blockModuleChunkX * sumWidth;\n const int blockModuleStartY = blockModuleChunkY * sumWidth;\n\n const int blockFilterIdx = B_X * filtersPerThread* (blockIdx.x % numFilterBlocks);\n\n// const int moduleStride = (imgSize - filterSize + 1) / numModulesX;\n const int numModules = numModulesY * numModulesX;\n\n const int blockPixelOffset = blockIdx.y * B_Y * pixelsPerThread;\n const int imgOffset = loadX;\n const int hidActsOffset = blockFilterIdx * numImages * numModules + loadX;\n// images += loadX;\n// hidActs += blockFilterIdx * numImages * numModules\n// + loadX;\n\n targets += (blockModuleChunkIdx * numFilters) * filterPixels * numColors\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + threadIdx.y * numFilters + threadIdx.x;\n\n //float* shImgLoad = &shImages[loadY][loadX];\n //float* shHidActLoad = &shHidActs[loadY][loadX];\n\n float prod[numColors][pixelsPerThread][filtersPerThread];\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[c][p][f] = 0;\n }\n }\n }\n const int mStartX = blockModuleStartX;\n const int mStartY = blockModuleStartY;\n const int mEndX = min(numModulesX, blockModuleStartX + sumWidth);\n const int mEndY = min(numModulesY, blockModuleStartY + sumWidth);\n\n const bool doWork = mStartY < mEndY && mStartX < mEndX;\n// if (!doWork) {\n// hidActs -=\n// }\n// if (mStartY == mEndY || mStartX == mEndX) {\n// return;\n// }\n\n// float imPreload[pixelCache * numColors * preloadCases / B_X]; // [12]\n float haPreload[filtersPerThread * preloadCases / B_Y]; // [8]\n// if (blockIdx.x != 0 || blockIdx.y !=0) {\n// return;\n// }\n// printf(\"mStartX: %d, mStartX: %d, mStartX: %d, mStartX: %d\\n\", mStartX, mStartY, mEndX, mEndY);\n const int fYOff = (blockPixelOffset + tidx) / filterSize;\n const int fXOff = (blockPixelOffset + tidx) % filterSize;\n __shared__ int pxIdxes[B_Y*pixelsPerThread];\n// __shared__ int fidx[filtersPerThread * preloadCases / B_Y]; // [8]\n\n int m = mStartY * numModulesX + mStartX;\n\n int fidx[filtersPerThread * preloadCases / B_Y];\n if (doWork) {\n #pragma unroll\n for (int y = 0; y < filtersPerThread * preloadCases / B_Y; ++y) {\n const int fIdx = WA_3_FIDX(y);\n// if (doWork) {\n haPreload[y] = tex1Dfetch(hidActs, hidActsOffset + fIdx * numImages * numModules + m * numImages);\n// }\n fidx[y] = fIdx * numImages * numModules;\n }\n }\n\n for (int my = mStartY; my < mEndY; my++) {\n const int imgLoadModPosY = paddingStart + my * moduleStride;\n for (int mx = mStartX; mx < mEndX; mx++) {\n m = my * numModulesX + mx;\n\n// __syncthreads();\n const int imgLoadModPosX = paddingStart + mx * moduleStride;\n if (tidx < B_Y * pixelsPerThread) {\n// const int imgLoadModPosY = paddingStart + my * moduleStride;\n// const int imgLoadModPosX = paddingStart + mx * moduleStride;\n const int pxY = (imgLoadModPosY + fYOff);\n const int pxX = (imgLoadModPosX + fXOff);\n const int pixIdx = (pxY * imgSizeX + pxX) * imgStride;\n pxIdxes[tidx] = pxY >= 0 && pxY < imgSizeY && pxX >= 0 && pxX < imgSizeX ? pixIdx : -1;\n }\n __syncthreads();\n\n int myNext = my, mxNext = mx, mNext = m;\n const bool lastModule = my == mEndY - 1 && mx == mEndX - 1;\n\n if (!lastModule) {\n mxNext = mx + 1 == mEndX ? mStartX : mx + 1;\n myNext = my + (mx + 1 == mEndX);\n mNext = myNext * numModulesX + mxNext;\n }\n\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n const bool lastBatch = caseIdx + preloadCases == numImages;\n// const float* im = &images[caseIdx + preloadCases + pixIdx];\n// const float* ha = &hidActs[caseIdx + preloadCases + m * numImages];\n int hidActsOffset2 = hidActsOffset + caseIdx + preloadCases + m * numImages;\n\n if (lastBatch) {\n// ha = &hidActs[mNext * numImages];\n hidActsOffset2 = hidActsOffset + mNext * numImages;\n }\n\n #pragma unroll\n for (int y = 0; y < B_X*filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n shHidActs[loadY+y][loadX] = haPreload[y*preloadCases/(B_X*B_Y)];\n }\n\n /* ==================================================================================\n * Iteration 0\n * ==================================================================================\n */\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = 0;\n }\n }\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n const int pxIdx = 0 * B_Y + loadY + y; // pixel idx in filter\n if (pxIdx + blockPixelOffset < filterPixels) {\n const int pixIdx = pxIdxes[pxIdx];//(pxY * imgSizeX + pxX) * imgStride;\n if (pixIdx >= 0) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = tex1Dfetch(images, imgOffset + caseIdx + c * imgPixels * imgStride + pixIdx);\n }\n }\n }\n }\n\n __syncthreads();\n\n haPreload[0] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[0]);\n haPreload[1] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[1]);\n WA_C3_LOOP(0,0);\n haPreload[2] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[2]);\n haPreload[3] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[3]);\n WA_C3_LOOP(0,1);\n haPreload[4] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[4]);\n haPreload[5] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[5]);\n WA_C3_LOOP(0,2);\n haPreload[6] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[6]);\n haPreload[7] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[7]);\n\n __syncthreads();\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleTargets * targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n } else {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n// if (threadIdx.x == 3)\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n }\n}\n\n\n/*\n * Each block computes weight gradients for B_Y * pixelsPerThread pixels and B_X filters\n * threadIdx.x determines filter\n * threadIdx.y determines pixel in filter\n *\n * blockIdx.x determines filter batch of B_X * filtersPerThread, module batch of partialSum\n * blockIdx.y determines pixel batch of B_Y * pixelsPerThread\n *\n * Number of filters must be divisible by B_X * filtersPerThread\n * Number of images (cases) should be divisible by preloadCases if checkCaseBounds is false.\n *\n * images: (numColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numColors, filterPixels, numFilters)\n *\n * B_Y * B_X should be divisible by preloadCases.\n * preloadCases one of 16, 32.\n * B_X one of 4, 8, 16, 32\n * B_Y arbitrary (satisfying divisibility constraints)\n * numModules must be divisible by partialSum\n * pixelsPerThread must be divisible by pixelCache\n *\n * After adding pixelsPerThread, register usage went from 20 to 23 (when pixelsPerThread = 1)...\n * so the compiler is messing up here somehow. It's unable to optimize that case away.\n */\ntemplate \n__launch_bounds__(256,2)\n__global__ void conv_weight_acts_c_preload_pc_2_pt_4_f_3_r_32_c_3(cudaTextureObject_t images, cudaTextureObject_t hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int sumWidth,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImages[pixelCache * B_Y * numColors][preloadCases]; // preload preloadCases cases of B_Y * pixelsPerThread pixels\n __shared__ float shHidActs[B_X * filtersPerThread][preloadCases + 1]; // preload preloadCases cases of B_X hidActs\n\n const int tidx = B_X * threadIdx.y + threadIdx.x;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X*filtersPerThread);\n\n const int blockModuleChunkIdx = blockIdx.x / numFilterBlocks;\n\n const int numModuleChunksX = DIVUP(numModulesX, sumWidth);\n// const int numModuleChunksY = DIVUP(numModulesY, sumWidth);\n\n const int blockModuleChunkX = blockModuleChunkIdx % numModuleChunksX;\n const int blockModuleChunkY = blockModuleChunkIdx / numModuleChunksX;\n\n const int blockModuleStartX = blockModuleChunkX * sumWidth;\n const int blockModuleStartY = blockModuleChunkY * sumWidth;\n\n const int blockFilterIdx = B_X * filtersPerThread* (blockIdx.x % numFilterBlocks);\n\n// const int moduleStride = (imgSize - filterSize + 1) / numModulesX;\n const int numModules = numModulesY * numModulesX;\n\n const int blockPixelOffset = blockIdx.y * B_Y * pixelsPerThread;\n const int imgOffset = loadX;\n const int hidActsOffset = blockFilterIdx * numImages * numModules\n + loadX;\n// images += loadX;\n// hidActs += blockFilterIdx * numImages * numModules\n// + loadX;\n\n targets += (blockModuleChunkIdx * numFilters) * filterPixels * numColors\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + threadIdx.y * numFilters + threadIdx.x;\n\n //float* shImgLoad = &shImages[loadY][loadX];\n //float* shHidActLoad = &shHidActs[loadY][loadX];\n\n float prod[numColors][pixelsPerThread][filtersPerThread];\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n prod[c][p][f] = 0;\n }\n }\n }\n const int mStartX = blockModuleStartX;\n const int mStartY = blockModuleStartY;\n const int mEndX = min(numModulesX, blockModuleStartX + sumWidth);\n const int mEndY = min(numModulesY, blockModuleStartY + sumWidth);\n\n const bool doWork = mStartY < mEndY && mStartX < mEndX;\n// if (mStartY == mEndY || mStartX == mEndX) {\n// return;\n// }\n\n// float imPreload[pixelCache * numColors * preloadCases / B_X]; // [12]\n float haPreload[filtersPerThread * preloadCases / B_Y]; // [6]\n// if (blockIdx.x != 0 || blockIdx.y !=0) {\n// return;\n// }\n// printf(\"mStartX: %d, mStartX: %d, mStartX: %d, mStartX: %d\\n\", mStartX, mStartY, mEndX, mEndY);\n const int fYOff = (blockPixelOffset + tidx) / filterSize;\n const int fXOff = (blockPixelOffset + tidx) % filterSize;\n __shared__ int pxIdxes[B_Y*pixelsPerThread];\n// __shared__ int fidx[filtersPerThread * preloadCases / B_Y]; // [6]\n\n int m = mStartY * numModulesX + mStartX;\n int fidx[filtersPerThread * preloadCases / B_Y];\n// if (doWork) {\n #pragma unroll\n for (int y = 0; y < filtersPerThread * preloadCases / B_Y; ++y) {\n fidx[y] = WA_3_FIDX(y) * numImages * numModules;\n if (doWork) { // Not actually necessary, I think\n haPreload[y] = tex1Dfetch(hidActs, hidActsOffset + fidx[y] + m * numImages);\n }\n }\n// }\n int mNext = mStartY * numModulesX + mStartX;\n for (int my = mStartY; my < mEndY; my++) {\n// const int imgLoadModPosY = paddingStart + my * moduleStride;\n for (int mx = mStartX; mx < mEndX; mx++) {\n m = mNext;//my * numModulesX + mx;\n\n// __syncthreads();\n// const int imgLoadModPosX = paddingStart + mx * moduleStride;\n if (tidx < B_Y * pixelsPerThread) {\n const int imgLoadModPosY = paddingStart + my * moduleStride;\n const int imgLoadModPosX = paddingStart + mx * moduleStride;\n const int pxY = (imgLoadModPosY + fYOff);\n const int pxX = (imgLoadModPosX + fXOff);\n const int pixIdx = (pxY * imgSizeX + pxX) * imgStride;\n pxIdxes[tidx] = pxY >= 0 && pxY < imgSizeY && pxX >= 0 && pxX < imgSizeX ? pixIdx : -1;\n }\n __syncthreads();\n\n\n const bool lastModule = my == mEndY - 1 && mx == mEndX - 1;\n mNext = lastModule * m + !lastModule * ((my + (mx + 1 == mEndX)) * numModulesX + (mx + 1 == mEndX ? mStartX : mx + 1));\n// if (!lastModule) {\n// const int mxNext = mx + 1 == mEndX ? mStartX : mx + 1;\n// const int myNext = my + (mx + 1 == mEndX);\n// mNext = myNext * numModulesX + mxNext;\n// }\n\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n const bool lastBatch = caseIdx + preloadCases == numImages;\n// const float* im = &images[caseIdx + preloadCases + pixIdx];\n// const float* ha = hidActs + !lastBatch * (caseIdx + preloadCases + m * numImages) + lastBatch * mNext * numImages;\n const int hidActsOffset2 = hidActsOffset + !lastBatch * (caseIdx + preloadCases + m * numImages) + lastBatch * mNext * numImages;\n// if (lastBatch) {\n// ha = &hidActs[mNext * numImages];\n// }\n\n #pragma unroll\n for (int y = 0; y < B_X*filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n shHidActs[loadY+y][loadX] = haPreload[y*preloadCases/(B_X*B_Y)];\n }\n\n /* ==================================================================================\n * Iteration 0\n * ==================================================================================\n */\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y * pixelCache) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y * pixelCache) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = 0;\n }\n }\n }\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y * pixelCache) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y * pixelCache) {\n const int pxIdx = 0 * B_Y + loadY + y; // pixel idx in filter\n const int pixIdx = pxIdxes[pxIdx];//(pxY * imgSizeX + pxX) * imgStride;\n if (pixIdx >= 0 && pxIdx + blockPixelOffset < filterPixels && (!checkCaseBounds || caseIdx + loadX < numImages)) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = tex1Dfetch(images, imgOffset + caseIdx + c * imgPixels * imgStride + pixIdx);\n }\n }\n }\n }\n\n __syncthreads();\n\n haPreload[0] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[0]);\n haPreload[1] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[1]);\n haPreload[2] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[2]);\n haPreload[3] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[3]);\n haPreload[4] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[4]);\n haPreload[5] = tex1Dfetch(hidActs, hidActsOffset2 + fidx[5]);\n\n WA_C3_LOOP2(0);\n\n __syncthreads();\n\n /* ==================================================================================\n * Iteration 1\n * ==================================================================================\n */\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y * pixelCache) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y * pixelCache) {\n// const int pxIdx = 2 * B_Y + loadY + y; // pixel idx in filter\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = 0;\n }\n }\n }\n\n #pragma unroll\n for (int y = 0; y < B_Y * pixelCache; y += (B_X * B_Y) / preloadCases) {\n // Make sure number of rows in the array is divisible by number of rows filled per iteration\n if ((B_Y * pixelCache) % (B_X * B_Y / preloadCases) == 0 || y + loadY < B_Y * pixelCache) {\n const int pxIdx = 2 * B_Y + loadY + y; // pixel idx in filter\n const int pixIdx = pxIdxes[pxIdx];//(pxY * imgSizeX + pxX) * imgStride;\n if (pixIdx >= 0 && pxIdx + blockPixelOffset < filterPixels && (!checkCaseBounds || caseIdx + loadX < numImages)) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n shImages[loadY+y + c * pixelCache * B_Y][loadX] = tex1Dfetch(images, imgOffset + caseIdx + c * imgPixels * imgStride + pixIdx);\n }\n }\n }\n }\n\n __syncthreads();\n\n WA_C3_LOOP2(2);\n\n __syncthreads();\n\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleTargets * targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n } else {\n #pragma unroll\n for (int p = 0; p < pixelsPerThread; p++) {\n if (blockPixelOffset + p * B_Y + threadIdx.y < filterPixels) {\n #pragma unroll\n for (int c = 0; c < numColors; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[p * B_Y * numFilters + c * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[c][p][f];\n }\n }\n }\n }\n }\n}\n\n/*****************************Function Revision Record*****************************\n * Author: Tencent BestImage Team(ankerguo@tencent.com) *\n * Date: 2015-05-18 *\n * Reason: Optimizing kernel to get faster speed according to GPU features *\n * Method: *\n * 1. reorganizing data structure to avoid bank conflict; *\n * 2. using vectorized data type; *\n * 3. improving instruction-level parallelism; *\n * 4. removing redundant 'if' branches; *\n * 5. removing local variables to save registers. *\n *********************************************************************************/\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numFilterColors, filterPixels, numFilters)\n */\ntemplate \n__launch_bounds__(128, 4)\n__global__ void conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_16_f_4_c_8_r_16(cudaTextureObject_t images, cudaTextureObject_t hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int numImgColors, const int numGroups, const int sumWidth,\n const float scaleTargets, const float scaleOutputs) {\n // avoid bank conflict by reorganizing the data structure, and improve the band width by using 'float2' instead of 'float'\n __shared__ float2 shImages[preloadCases][colorsPerThread * B_Y / 2 + 2]; // preload preloadCases cases\n __shared__ float2 shHidActs[preloadCases][filtersPerThread * B_X / 2 + 2]; // preload preloadCases cases of B_X hidacts\n\n const int tx = threadIdx.x % B_X, ty = threadIdx.y % B_Y;\n const int tidx = B_X * ty + tx;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X * filtersPerThread);\n const int blockModuleChunkIdx = blockIdx.x / numFilterBlocks;\n\n const int numModuleChunksX = DIVUP(numModulesX, sumWidth);\n// const int numModuleChunksY = DIVUP(numModulesY, sumWidth);\n\n const int blockModuleChunkX = blockModuleChunkIdx % numModuleChunksX;\n const int blockModuleChunkY = blockModuleChunkIdx / numModuleChunksX;\n\n const int blockModuleStartX = blockModuleChunkX * sumWidth;\n const int blockModuleStartY = blockModuleChunkY * sumWidth;\n\n// const int moduleIdx = partialSum * outputModuleIdx;\n const int blockFilterIdx = filtersPerThread * B_X * (blockIdx.x % numFilterBlocks);\n const int numModules = numModulesY * numModulesX;\n\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n const int numFilterColors = numImgColors / numGroups;\n\n const int blockPixelOffset = blockIdx.z; // pixel idx in filter\n const int blockPixelY = blockPixelOffset / filterSize, blockPixelX = blockPixelOffset % filterSize;\n const int blockFilterColorIdx = blockIdx.y * B_Y * colorsPerThread;\n const int imgColorIdx = blockFilterColorIdx + blockGroupIdx * numFilterColors;\n const int imgOffset = (imgColorIdx + loadY) * imgPixels * imgStride + loadX;\n// images += (imgColorIdx + loadY) * imgPixels * imgStride + loadX;\n const int hidActsOffset = blockFilterIdx * numImages * numModules\n + loadY * numImages * numModules\n + loadX;\n//\n// hidActs +=\n// blockFilterIdx * numImages * numModules\n// + loadY * numImages * numModules\n// + loadX;\n\n targets += blockModuleChunkIdx * numFilters * filterPixels * numFilterColors\n + (blockFilterColorIdx + ty) * filterPixels * numFilters\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + tx;\n // if (blockIdx.x != 0 || blockIdx.y != 0 || blockIdx.z != 0) return;\n\n const int mStartX = max(blockModuleStartX, DIVUP(-blockPixelX - paddingStart, moduleStride));\n const int mStartY = max(blockModuleStartY, DIVUP(-blockPixelY - paddingStart, moduleStride));\n const int mEndX = min(numModulesX, min(blockModuleStartX + sumWidth, DIVUP(imgSizeX - blockPixelX - paddingStart, moduleStride)));\n const int mEndY = min(numModulesY, min(blockModuleStartY + sumWidth, DIVUP(imgSizeY - blockPixelY - paddingStart, moduleStride)));\n\n // if (mStartY == mEndY || mStartX == mEndX) {\n // return;\n // }\n const bool doWork = mStartY < mEndY && mStartX < mEndX;\n\n // reduce 2 registers\n //float* shHidActLoad = &shHidActs[loadY][loadX];\n //float* shImgLoad = &shImages[loadY][loadX];\n\n float imPreload[preloadCases*colorsPerThread/B_X]; // [8]\n float haPreload[preloadCases*filtersPerThread/B_Y]; // [8]\n\n float prod[filtersPerThread][colorsPerThread];\n\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[f][c] = 0;\n }\n }\n int pixIdx, pixIdxNext, m, mNext;\n\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16_setCoords(\n mStartY, mStartX, paddingStart, numModulesX, moduleStride,\n blockPixelY, blockPixelX, imgSizeX, imgStride,\n pixIdx, m);\n\n if (doWork) {\n #pragma unroll\n for (int y = 0; y < B_Y * colorsPerThread; y += (B_X * B_Y) / preloadCases) {\n // It's bizarre, but this is the fastest way I've found to get it not to load nonexistent pixels.\n // All other ways cause crazy excessive register usage.\n const int idx = (mStartY < mEndY && mStartX < mEndX) * (0 + y * imgPixels * imgStride + pixIdx);\n imPreload[y * preloadCases/(B_X * B_Y)] = tex1Dfetch(images, imgOffset + idx);\n }\n }\n \n if (doWork) {\n #pragma unroll\n for (int y = 0; y < B_X * filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n // Almost certainly not necessary here.\n const int idx = (mStartY < mEndY && mStartX < mEndX) * (0 + y * numImages * numModules + m * numImages);\n haPreload[y * preloadCases / (B_X * B_Y)] = tex1Dfetch(hidActs, hidActsOffset + idx);\n }\n }\n\n\n for (int my = mStartY; my < mEndY; my++) {\n for (int mx = mStartX; mx < mEndX; mx++) {\n int myNext = my, mxNext = mx;\n const bool lastModule = my == mEndY - 1 && mx == mEndX - 1;\n\n if (!lastModule) {\n mxNext = mx + 1 == mEndX ? mStartX : mx + 1;\n myNext = my + (mx + 1 == mEndX);\n }\n\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16_setCoords(\n myNext, mxNext, paddingStart, numModulesX, moduleStride,\n blockPixelY, blockPixelX, imgSizeX, imgStride,\n pixIdxNext, mNext);\n\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n // store the preloaded image's pixel into shared memory\n #pragma unroll\n for (int y = 0; y < 4; y++) {\n shImages[loadX][loadY+y*8].x = imPreload[y];\n shImages[loadX][loadY+y*8].y = imPreload[y+4];\n }\n //const float* im = &images[caseIdx + preloadCases + pixIdx];\n //const float* ha = &hidActs[caseIdx + preloadCases + m * numImages];\n int imgOffset2 = imgOffset + caseIdx + preloadCases + pixIdx;\n int hidActsOffset2 = hidActsOffset + caseIdx + preloadCases + m * numImages;\n if (caseIdx + preloadCases == numImages) {\n pixIdx = pixIdxNext;\n m = mNext;\n imgOffset2 = imgOffset + pixIdxNext;\n hidActsOffset2 = hidActsOffset + mNext * numImages;\n }\n \n // store the images and hidActs \n shHidActs[loadX][loadY].x = haPreload[0];\n shHidActs[loadX][loadY].y = haPreload[2];\n shHidActs[loadX][loadY+16].x = haPreload[4];\n shHidActs[loadX][loadY+16].y = haPreload[6];\n shHidActs[loadX][loadY+8].x = haPreload[1];\n shHidActs[loadX][loadY+8].y = haPreload[3];\n shHidActs[loadX][loadY+24].x = haPreload[5];\n shHidActs[loadX][loadY+24].y = haPreload[7];\n\n // preloade the image's and hidAct's pixel\n #pragma unroll\n for (int r = 0; r < 8; r++) {\n imPreload[r] = tex1Dfetch(images, imgOffset2 + (r) * 8 * imgPixels * imgStride);\n haPreload[r] = tex1Dfetch(hidActs, hidActsOffset2 + (r) * 8 * numImages * numModules);\n }\n\n __syncthreads();\n // put together the instructions of same type to improve instruction-level parallelism\n #pragma unroll\n for (int r = 0; r < 16; r++) {\n for (int c = 0; c < 4; c++) { \n prod[0][c] += shImages[r][ty + c * B_Y].x * shHidActs[(r)][tx].x; \n prod[1][c] += shImages[r][ty + c * B_Y].x * shHidActs[(r)][tx].y; \n prod[2][c] += shImages[r][ty + c * B_Y].x * shHidActs[(r)][tx + B_X].x; \n prod[3][c] += shImages[r][ty + c * B_Y].x * shHidActs[(r)][tx + B_X].y; \n prod[0][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[(r)][tx].x; \n prod[1][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[(r)][tx].y; \n prod[2][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[(r)][tx + B_X].x; \n prod[3][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[(r)][tx + B_X].y; \n }\n }\n\n __syncthreads();\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleTargets * targets[c * B_Y * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[f][c];\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[f][c];\n }\n }\n }\n}\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numFilterColors, filterPixels, numFilters)\n */\ntemplate \n__launch_bounds__(256, 2)\n__global__ void conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_6_r_32(cudaTextureObject_t images, cudaTextureObject_t hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int numImgColors, const int numGroups, const int sumWidth,\n const float scaleTargets, const float scaleOutputs) {\n __shared__ float shImages[colorsPerThread * B_Y][preloadCases]; // preload preloadCases cases\n __shared__ float shHidActs[filtersPerThread * B_X][preloadCases + 1]; // preload preloadCases cases of B_X hidacts\n\n const int tidx = B_X * threadIdx.y + threadIdx.x;\n const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n const int filterPixels = filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X * filtersPerThread);\n const int blockModuleChunkIdx = blockIdx.x / numFilterBlocks;\n\n const int numModuleChunksX = DIVUP(numModulesX, sumWidth);\n// const int numModuleChunksY = DIVUP(numModulesY, sumWidth);\n\n const int blockModuleChunkX = blockModuleChunkIdx % numModuleChunksX;\n const int blockModuleChunkY = blockModuleChunkIdx / numModuleChunksX;\n\n const int blockModuleStartX = blockModuleChunkX * sumWidth;\n const int blockModuleStartY = blockModuleChunkY * sumWidth;\n\n// const int moduleIdx = partialSum * outputModuleIdx;\n const int blockFilterIdx = filtersPerThread * B_X * (blockIdx.x % numFilterBlocks);\n const int numModules = numModulesY * numModulesX;\n\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n const int numFilterColors = numImgColors / numGroups;\n\n const int blockPixelOffset = blockIdx.z; // pixel idx in filter\n const int blockPixelY = blockPixelOffset / filterSize, blockPixelX = blockPixelOffset % filterSize;\n const int blockFilterColorIdx = blockIdx.y * B_Y * colorsPerThread;\n const int imgColorIdx = blockFilterColorIdx + blockGroupIdx * numFilterColors;\n\n const int imgOffset = (imgColorIdx + loadY) * imgPixels * imgStride + loadX;\n const int hidActsOffset = blockFilterIdx * numImages * numModules\n + loadY * numImages * numModules\n + loadX;\n// images += (imgColorIdx + loadY) * imgPixels * imgStride + loadX;\n//\n// hidActs +=\n// blockFilterIdx * numImages * numModules\n// + loadY * numImages * numModules\n// + loadX;\n\n targets += blockModuleChunkIdx * numFilters * filterPixels * numFilterColors\n + (blockFilterColorIdx + threadIdx.y) * filterPixels * numFilters\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + threadIdx.x;\n// if (blockIdx.x != 0 || blockIdx.y != 0 || blockIdx.z != 0) return;\n\n const int mStartX = max(blockModuleStartX, DIVUP(-blockPixelX - paddingStart, moduleStride));\n const int mStartY = max(blockModuleStartY, DIVUP(-blockPixelY - paddingStart, moduleStride));\n const int mEndX = min(numModulesX, min(blockModuleStartX + sumWidth, DIVUP(imgSizeX - blockPixelX - paddingStart, moduleStride)));\n const int mEndY = min(numModulesY, min(blockModuleStartY + sumWidth, DIVUP(imgSizeY - blockPixelY - paddingStart, moduleStride)));\n\n// if (mStartY == mEndY || mStartX == mEndX) {\n// return;\n// }\n const bool doWork = mStartY < mEndY && mStartX < mEndX;\n\n float* shHidActLoad = &shHidActs[loadY][loadX];\n float* shImgLoad = &shImages[loadY][loadX];\n\n float imPreload[preloadCases*colorsPerThread/B_X]; // [6]\n float haPreload[preloadCases*filtersPerThread/B_Y]; // [16]\n\n float prod[filtersPerThread][colorsPerThread];\n\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[f][c] = 0;\n }\n }\n int pixIdx, pixIdxNext, m, mNext;\n\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16_setCoords(\n mStartY, mStartX, paddingStart, numModulesX, moduleStride,\n blockPixelY, blockPixelX, imgSizeX, imgStride,\n pixIdx, m);\n\n if (doWork) {\n #pragma unroll\n for (int y = 0; y < B_Y * colorsPerThread; y += (B_X * B_Y) / preloadCases) {\n imPreload[y * preloadCases/(B_X * B_Y)] = tex1Dfetch(images, imgOffset + y * imgPixels * imgStride + pixIdx);\n }\n\n #pragma unroll\n for (int y = 0; y < B_X * filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n haPreload[y * preloadCases / (B_X * B_Y)] = tex1Dfetch(hidActs, hidActsOffset + y * numImages * numModules + m * numImages);\n }\n }\n// if (mStartY > mEndY || mStartX > mEndX) {\n// printf(\"crzy!!\\n\");\n// }\n\n for (int my = mStartY; my < mEndY; my++) {\n for (int mx = mStartX; mx < mEndX; mx++) {\n int myNext = my, mxNext = mx;\n const bool lastModule = my == mEndY - 1 && mx == mEndX - 1;\n\n if (!lastModule) {\n mxNext = mx + 1 == mEndX ? mStartX : mx + 1;\n myNext = my + (mx + 1 == mEndX);\n }\n\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16_setCoords(\n myNext, mxNext, paddingStart, numModulesX, moduleStride,\n blockPixelY, blockPixelX, imgSizeX, imgStride,\n pixIdxNext, mNext);\n\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n #pragma unroll\n for (int y = 0; y < B_Y * colorsPerThread; y += (B_X * B_Y) / preloadCases) {\n shImgLoad[(y) * preloadCases] = imPreload[y * preloadCases / (B_X * B_Y)];\n }\n\n #pragma unroll\n for (int y = 0; y < B_X * filtersPerThread; y += (B_X * B_Y) / preloadCases) {\n shHidActLoad[y * (preloadCases + 1)] = haPreload[y * preloadCases / (B_X * B_Y)];\n }\n\n __syncthreads();\n\n// const float* im = &images[caseIdx + preloadCases + pixIdx];\n// const float* ha = &hidActs[caseIdx + preloadCases + m * numImages];\n int imgOffset2 = imgOffset + caseIdx + preloadCases + pixIdx;\n int hidActsOffset2 = hidActsOffset + caseIdx + preloadCases + m * numImages;\n if (caseIdx + preloadCases == numImages) {\n pixIdx = pixIdxNext;\n m = mNext;\n imgOffset2 = imgOffset + pixIdxNext;\n hidActsOffset2 = hidActsOffset + mNext * numImages;\n }\n\n WA_LOOP(0);\n WA_LOOP(1);\n WA_LOOP(2);\n WA_LOOP(3);\n WA_LOOP(4);\n\n WA_LOOP(5);\n WA_IMLOAD_TX(0);\n WA_LOOP(6);\n WA_IMLOAD_TX(1);\n WA_LOOP(7);\n WA_IMLOAD_TX(2);\n WA_LOOP(8);\n WA_IMLOAD_TX(3);\n WA_LOOP(9);\n WA_IMLOAD_TX(4);\n WA_LOOP(10);\n WA_IMLOAD_TX(5);\n\n WA_LOOP(11);\n WA_HALOAD_TX(0);\n WA_LOOP(12);\n WA_HALOAD_TX(1);\n WA_LOOP(13);\n WA_HALOAD_TX(2);\n WA_LOOP(14);\n WA_HALOAD_TX(3);\n WA_LOOP(15);\n WA_HALOAD_TX(4);\n WA_LOOP(16);\n WA_HALOAD_TX(5);\n WA_LOOP(17);\n WA_HALOAD_TX(6);\n WA_LOOP(18);\n WA_HALOAD_TX(7);\n WA_LOOP(19);\n WA_HALOAD_TX(8);\n WA_LOOP(20);\n WA_HALOAD_TX(9);\n WA_LOOP(21);\n WA_HALOAD_TX(10);\n WA_LOOP(22);\n WA_HALOAD_TX(11);\n WA_LOOP(23);\n WA_HALOAD_TX(12);\n WA_LOOP(24);\n WA_HALOAD_TX(13);\n WA_LOOP(25);\n WA_HALOAD_TX(14);\n WA_LOOP(26);\n WA_HALOAD_TX(15);\n\n WA_LOOP(27);\n WA_LOOP(28);\n WA_LOOP(29);\n WA_LOOP(30);\n WA_LOOP(31);\n\n __syncthreads();\n }\n }\n }\n\n if (scale) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleTargets * targets[c * B_Y * filterPixels * numFilters + f * B_X] + scaleOutputs * prod[f][c];\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixels * numFilters + f * B_X] = scaleOutputs * prod[f][c];\n }\n }\n }\n}\n\n/*****************************Function Revision Record*****************************\n * Author: Tencent BestImage Team(ankerguo@tencent.com) *\n * Date: 2015-05-18 *\n * Reason: Optimizing kernel to get faster speed according to GPU features *\n * Method: *\n * 1. reorganizing data structure to avoid bank conflict; *\n * 2. using vectorized data type; *\n * 3. improving instruction-level parallelism; *\n * 4. removing redundant 'if' branches; *\n * 5. removing local variables to save registers. *\n *********************************************************************************/\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModulesY, numModulesX, numImages)\n *\n * targets: (numModulesY*numModulesX/partialSum, numFilterColors, filterPixels, numFilters)\n */\ntemplate \n__launch_bounds__(256, 2)\n__global__ void conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16(cudaTextureObject_t images, cudaTextureObject_t hidActs, float* targets,\n const int numImages, const int numFilters,\n const int numModulesY, const int numModulesX,\n const int imgSizeY, const int imgSizeX, const int filterSize,\n const int paddingStart, const int moduleStride, const int imgStride,\n const int numImgColors, const int numGroups, const int sumWidth,\n const float scaleTargets, const float scaleOutputs) {\n // avoid bank conflict by re-organizing the data structure, and improve band width by using 'float2' instead of 'float'\n __shared__ float2 shImages[preloadCases][colorsPerThread * B_Y / 2 + 2]; // preload preloadCases cases\n __shared__ float2 shHidActs[preloadCases][filtersPerThread * B_X / 2 + 2]; // preload preloadCases cases of B_X hidacts\n const int tx = threadIdx.x % B_X, ty = threadIdx.y % B_Y;\n //const int tidx = B_X * threadIdx.y + threadIdx.x;\n // reduce two registers\n //const int loadY = tidx / preloadCases, loadX = tidx % preloadCases;\n\n //const int filterPixels = filterSize * filterSize;\n // reduce one register\n const int filterPixelsAll = numFilters * filterSize * filterSize;\n const int imgPixels = imgSizeY * imgSizeX;\n\n const int numFilterBlocks = numFilters / (B_X * filtersPerThread);\n const int blockModuleChunkIdx = blockIdx.x / numFilterBlocks;\n\n const int numModuleChunksX = DIVUP(numModulesX, sumWidth);\n // const int numModuleChunksY = DIVUP(numModulesY, sumWidth);\n\n const int blockModuleChunkX = blockModuleChunkIdx % numModuleChunksX;\n const int blockModuleChunkY = blockModuleChunkIdx / numModuleChunksX;\n\n const int blockModuleStartX = blockModuleChunkX * sumWidth;\n const int blockModuleStartY = blockModuleChunkY * sumWidth;\n\n // const int moduleIdx = partialSum * outputModuleIdx;\n const int blockFilterIdx = filtersPerThread * B_X * (blockIdx.x % numFilterBlocks);\n const int numModules = numModulesY * numModulesX;\n\n const int numFiltersPerGroup = numFilters / numGroups;\n const int blockGroupIdx = blockFilterIdx / numFiltersPerGroup;\n const int numFilterColors = numImgColors / numGroups;\n\n const int blockPixelOffset = blockIdx.z; // pixel idx in filter\n const int blockPixelY = blockPixelOffset / filterSize, blockPixelX = blockPixelOffset % filterSize;\n const int blockFilterColorIdx = blockIdx.y * B_Y * colorsPerThread;\n const int imgColorIdx = blockFilterColorIdx + blockGroupIdx * numFilterColors;\n const int imgOffset = (imgColorIdx + (ty * B_X + tx) / preloadCases) * imgPixels * imgStride + (ty * B_X + tx) % preloadCases;\n // images += (imgColorIdx + loadY) * imgPixels * imgStride + loadX;\n const int hidActsOffset = blockFilterIdx * numImages * numModules\n + ((ty * B_X + tx) / preloadCases) * numImages * numModules\n + ((ty * B_X + tx) % preloadCases);\n //\n // hidActs +=\n // blockFilterIdx * numImages * numModules\n // + loadY * numImages * numModules\n // + loadX;\n\n // usie one temporary register instead of multiple registers\n const int pIdxBase = imgStride * ((paddingStart + blockPixelY) * imgSizeX + paddingStart + blockPixelX);\n\n targets += blockModuleChunkIdx * numFilters * filterSize * filterSize * numFilterColors\n + (blockFilterColorIdx + ty) * filterSize * filterSize * numFilters\n + blockPixelOffset * numFilters\n + blockFilterIdx\n + tx;\n // if (blockIdx.x != 0 || blockIdx.y != 0 || blockIdx.z != 0) return;\n\n const int mStartX = max(blockModuleStartX, DIVUP(-blockPixelX - paddingStart, moduleStride));\n const int mStartY = max(blockModuleStartY, DIVUP(-blockPixelY - paddingStart, moduleStride));\n const int mEndX = min(numModulesX, min(blockModuleStartX + sumWidth, DIVUP(imgSizeX - blockPixelX - paddingStart, moduleStride)));\n const int mEndY = min(numModulesY, min(blockModuleStartY + sumWidth, DIVUP(imgSizeY - blockPixelY - paddingStart, moduleStride)));\n\n // reduce 3 registers\n const bool doWork = mStartY < mEndY && mStartX < mEndX;\n\n //float* shHidActLoad = &shHidActs[loadY][loadX];\n //float* shImgLoad = &shImages[loadY][loadX];\n\n float imPreload[preloadCases*colorsPerThread/B_X]; // [4]\n float haPreload[preloadCases*filtersPerThread/B_Y]; // [8]\n\n float prod[filtersPerThread][colorsPerThread];\n\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n prod[f][c] = 0;\n }\n }\n //int pixIdx, pixIdxNext, m, mNext;\n\n //conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16_setCoords(\n // mStartY, mStartX, paddingStart, numModulesX, moduleStride,\n // blockPixelY, blockPixelX, imgSizeX, imgStride,\n // pixIdx, m);\n \n const int pixIdx = pIdxBase + (mStartY * imgSizeX + mStartX) * moduleStride * imgStride;\n const int m = (mStartY * numModulesX + mStartX);\n\n // preload the image's pixel \n if (doWork && (ty * B_X + tx) / preloadCases < (B_Y * colorsPerThread / 4)) {\n #pragma unroll\n for (int i = 0; i < 4; i++) {\n imPreload[i] = tex1Dfetch(images, imgOffset + 16 * i * imgPixels * imgStride + pixIdx);\n }\n }\n\n // preload the hidAct's pixel\n if (doWork && (ty * B_X + tx) / preloadCases < (B_X * filtersPerThread) / 8) {\n #pragma unroll\n for (int i = 0; i < 8; i++) {\n haPreload[i] = tex1Dfetch(hidActs, hidActsOffset + 16 * i * numImages * numModules + m * numImages);\n }\n }\n\n for (int my = mStartY; my < mEndY; my++) {\n for (int mx = mStartX; mx < mEndX; mx++) {\n\n for (int caseIdx = 0; caseIdx < numImages; caseIdx += preloadCases) {\n int imgOffset2 = imgOffset + caseIdx + preloadCases + pIdxBase + (my * imgSizeX + mx) * moduleStride * imgStride;\n int hidActsOffset2 = hidActsOffset + caseIdx + preloadCases + (my * numModulesX + mx) * numImages;\n\n if (caseIdx + preloadCases == numImages) {\n const int mxNext = mx + 1 == mEndX ? mStartX : mx + 1;\n const int myNext = my + (mx + 1 == mEndX);\n\n imgOffset2 = imgOffset + + pIdxBase + (myNext * imgSizeX + mxNext) * moduleStride * imgStride;\n hidActsOffset2 = hidActsOffset + (myNext * numModulesX + mxNext) * numImages;\n }\n\n if ((ty * B_X + tx) / preloadCases < (B_Y * colorsPerThread / 4)) {\n // store the previousely preloaded pixel into shared memory\n shImages[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases].x = imPreload[0];\n shImages[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases].y = imPreload[2];\n shImages[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 16].x = imPreload[1];\n shImages[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 16].y = imPreload[3];\n\t\t}\n\n if ((ty * B_X + tx) / preloadCases < (B_X * filtersPerThread / 8)) {\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases].x = haPreload[0];\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases].y = haPreload[2];\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 32].x = haPreload[4];\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 32].y = haPreload[6];\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 16].x = haPreload[1];\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 16].y = haPreload[3];\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 48].x = haPreload[5];\n shHidActs[(ty * B_X + tx) % preloadCases][(ty * B_X + tx) / preloadCases + 48].y = haPreload[7];\n\t\t}\n\n #pragma unroll\n for (int r = 0; r < 8; r++) {\n haPreload[r] = tex1Dfetch(hidActs, hidActsOffset2 + r * 16 * numImages * numModules);\n }\n\n #pragma unroll\n for (int r = 0; r < 4; r++) {\n imPreload[r] = tex1Dfetch(images, imgOffset2 + r * 16 * imgPixels * imgStride);\n }\n __syncthreads();\n\n // put together the instructions of same type to improve instruction-level parallelism\n // calculate the derivative of the hidAct with respect to weight\n #pragma unroll\n for (int r = 0; r < 16; r++) {\n #pragma unroll\n for (int c = 0; c < 4; c++) { \n prod[0][c] += shImages[r][ty + c * B_Y].x * shHidActs[r][tx].x; \n prod[1][c] += shImages[r][ty + c * B_Y].x * shHidActs[r][tx].y; \n prod[2][c] += shImages[r][ty + c * B_Y].x * shHidActs[r][tx + B_X].x; \n prod[3][c] += shImages[r][ty + c * B_Y].x * shHidActs[r][tx + B_X].y; \n prod[0][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[r][tx].x; \n prod[1][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[r][tx].y; \n prod[2][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[r][tx + B_X].x; \n prod[3][c+4] += shImages[r][ty + c * B_Y].y * shHidActs[r][tx + B_X].y; \n }\n } \n\n __syncthreads();\n } \n } \n } \n\n if (scale) {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixelsAll + f * B_X] = scaleTargets * targets[c * B_Y * filterPixelsAll + f * B_X] + scaleOutputs * prod[f][c];\n }\n }\n } else {\n #pragma unroll\n for (int c = 0; c < colorsPerThread; c++) {\n #pragma unroll\n for (int f = 0; f < filtersPerThread; f++) {\n targets[c * B_Y * filterPixelsAll + f * B_X] = scaleOutputs * prod[f][c];\n }\n }\n }\n}\n\nstd::pair getWeightActsOutputSize(int numModulesY, int numModulesX, int numFilterColors,\n int filterSize, int numFilters, int sumWidth) {\n const int outputModuleChunksX = DIVUP(numModulesX, sumWidth);\n const int outputModuleChunksY = DIVUP(numModulesY, sumWidth);\n const int outputModuleChunks = outputModuleChunksX * outputModuleChunksY;\n return std::pair(outputModuleChunks * numFilterColors * filterSize * filterSize, numFilters);\n}\n\n/*\n * images: (numImgColors, imgSizeY, imgSizeX, numImages), with stride given\n * hidActs: (numFilters, numModules, numImages)\n *\n * targets: (numModuleY*numModulesX/partialSum, numFilterColors, filterPixels, numFilters)\n *\n * TODO: you can get a slight speed boost for local non-convolutional units by writing special\n * routines for partialSum = 1. But I dunno if the code duplication is worth it...\n *\n * Note: all of these convolution routines are optimized for the case when\n * the number of images (i.e. the minibatch size) is a multiple of 128.\n * Other batch sizes will work, but but I made no attempt whatsoever\n * to make them work fast.\n */\nvoid _weightActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int filterSize, int paddingStart, int moduleStride, int numImgColors,\n int numGroups, int sumWidth, float scaleTargets, float scaleOutput) {\n CAFFE_ENFORCE(images->ndim() == 2);\n CAFFE_ENFORCE(hidActs->ndim() == 2);\n CAFFE_ENFORCE(targets->ndim() == 2);\n\n int numFilterColors = numImgColors / numGroups;\n int imgStride = images->dim32(1);\n int numImages = images->dim32(1);\n int imgPixels = images->dim32(0) / numImgColors;\n int imgSizeX = imgPixels / imgSizeY;\n int numModules = numModulesY * numModulesX;\n int numFilters = hidActs->dim32(0) / numModules;\n int numFiltersPerGroup = numFilters / numGroups;\n\n CAFFE_ENFORCE(numImgColors % numGroups == 0);\n CAFFE_ENFORCE(numFilters % (16*numGroups) == 0);\n CAFFE_ENFORCE(numGroups > 1 || (numImgColors > 0 && (numImgColors <= 3 || numImgColors % 16 == 0)));\n CAFFE_ENFORCE(numGroups == 1 || numFilterColors % 16 == 0);\n CAFFE_ENFORCE(imgSizeY * imgSizeX == imgPixels);\n CAFFE_ENFORCE(images->dim32(0) == imgPixels * numImgColors);\n\n int filterPixels = filterSize * filterSize;\n int outputModuleChunksX = DIVUP(numModulesX, sumWidth);\n int outputModuleChunksY = DIVUP(numModulesY, sumWidth);\n int outputModuleChunks = outputModuleChunksX * outputModuleChunksY;\n// partialSum = partialSum == 0 ? numModules : partialSum;\n\n// CAFFE_ENFORCE(numModules % partialSum == 0);\n CAFFE_ENFORCE(hidActs->dim32(1) == numImages);\n\n // These routines don't handle the case when only part of the image is visited in the convolution\n CAFFE_ENFORCE(paddingStart <= 0);\n CAFFE_ENFORCE(paddingStart + (numModulesX-1)*moduleStride + filterSize >= imgSizeX);\n CAFFE_ENFORCE(paddingStart + (numModulesY-1)*moduleStride + filterSize >= imgSizeY);\n CAFFE_ENFORCE(moduleStride <= filterSize);\n\n CAFFE_ENFORCE(numModules * numFilters == hidActs->dim32(0));\n\n int preloadCases = 32;\n\n dim3 blocks, threads;\n int bx, by;\n int pixelsPerThread, filtersPerThread, colorsPerThread;\n // Worth playing with these parameters to find best values for your problem.\n // These values work relatively well, but not optimal for all problems.\n if (numFilterColors > 3) {\n filtersPerThread = numFiltersPerGroup % 64 == 0 ? 4\n : numFiltersPerGroup % 32 == 0 ? 2\n : 1;\n colorsPerThread = numFilterColors % 64 == 0 ? 8\n : numFilterColors % 48 == 0 ? 6\n : numFilterColors % 32 == 0 ? 8\n : 4;\n by = (numFilterColors / colorsPerThread) % 8 == 0 ? 8 : 4;\n bx = numFiltersPerGroup % 128 == 0 ? 32 : 16;\n preloadCases = filtersPerThread * colorsPerThread < 32 ? 32 : 16;\n blocks = dim3(outputModuleChunks*(numFilters/(bx*filtersPerThread)), numFilterColors / (by*colorsPerThread), filterPixels);\n CAFFE_ENFORCE(numFilterColors % (by*colorsPerThread) == 0);\n } else { // This is ugly but it's nice to spell it out clearly\n CAFFE_ENFORCE(numGroups == 1); // Just for sanity\n // NOTE: these things are only optimized for colors = 3. I didn't really test other cases.\n if (numFilters % 64 == 0) { // TODO: having a separate case for 128 would make things faster, but I probably don't care about 128\n filtersPerThread = 4;\n pixelsPerThread = 2;\n by = 16;\n bx = 16;\n preloadCases = 32;\n } else if (numFilters % 48 == 0) {\n filtersPerThread = 3;\n pixelsPerThread = 4;\n by = 16;\n bx = 16;\n preloadCases = 32;\n } else if (numFilters % 32 == 0) {\n filtersPerThread = 2;\n pixelsPerThread = 2;\n by = 8;\n bx = 16;\n preloadCases = 16;\n } else { // This case is completely untested. It might be really slow. But no time now.\n filtersPerThread = 1;\n pixelsPerThread = 16;\n by = 16;\n bx = 16;\n preloadCases = 32;\n }\n blocks = dim3(outputModuleChunks*(numFilters/(bx*filtersPerThread)), DIVUP(filterPixels, by*pixelsPerThread));\n }\n CAFFE_ENFORCE((by * bx) % preloadCases == 0);\n CAFFE_ENFORCE(numFilters % (bx * filtersPerThread) == 0);\n threads = dim3(bx, by);\n bool checkCaseBounds = numImages % preloadCases != 0;\n bool scale = scaleTargets != 0;\n std::pair targetSize = getWeightActsOutputSize(numModulesY, numModulesX, numFilterColors, filterSize, numFilters, sumWidth);\n if (!scale) {\n targets->Resize(std::vector{targetSize.first, targetSize.second});\n } else {\n CAFFE_ENFORCE(targets->dim32(0) == targetSize.first);\n CAFFE_ENFORCE(targets->dim32(1) == targetSize.second);\n }\n\n cudaTextureObject_t tex_images = GetTensorTextureObject(images);\n cudaTextureObject_t tex_hidacts = GetTensorTextureObject(hidActs);\n float* images_data = images->mutable_data();\n float* hidacts_data = hidActs->mutable_data();\n float* targets_data = targets->mutable_data();\n const std::size_t images_bytes = images->nbytes();\n\n cudaStream_t stream = context->cuda_stream();\n \n checkCudaErrors(cudaDeviceSetSharedMemConfig(cudaSharedMemBankSizeEightByte));\n\n if (scale == false) {\n if (checkCaseBounds == false) {\n if (numFilterColors > 3) {\n if (numFilterColors % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16< 8, 32, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16< 8, 32, 4, 8, 16, false ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_16_f_4_c_8_r_16< 8, 16, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_16_f_4_c_8_r_16< 8, 16, 4, 8, 16, false ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_6_r_32< 8, 32, 4, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_6_r_32< 8, 32, 4, 6, 32, false ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput); }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_preload_pc_2_pt_2_f_4_r_32_c_3 < 16, 16, 2, 2, 4, 32, 3, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_preload_pc_2_pt_2_f_4_r_32_c_3 < 16, 16, 2, 2, 4, 32, 3, false, false ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_preload_pc_2_pt_4_f_3_r_32_c_3 < 16, 16, 2, 4, 3, 32, 3, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_preload_pc_2_pt_4_f_3_r_32_c_3 < 16, 16, 2, 4, 3, 32, 3, false, false ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 2) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 1) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, false, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, false, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (checkCaseBounds == true) {\n if (numFilterColors > 3) {\n if (numFilterColors % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 8, 16, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 8, 16, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 6, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, false >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 3, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 3, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 3, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 3, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 2) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 1) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, false, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, false, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n else if (scale == true) {\n if (checkCaseBounds == false) {\n if (numFilterColors > 3) {\n if (numFilterColors % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16< 8, 32, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_8_r_16< 8, 32, 4, 8, 16, true ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_16_f_4_c_8_r_16< 8, 16, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_16_f_4_c_8_r_16< 8, 16, 4, 8, 16, true ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_6_r_32< 8, 32, 4, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_preload_ty_8_tx_32_f_4_c_6_r_32< 8, 32, 4, 6, 32, true ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_preload_pc_2_pt_2_f_4_r_32_c_3 < 16, 16, 2, 2, 4, 32, 3, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_preload_pc_2_pt_2_f_4_r_32_c_3 < 16, 16, 2, 2, 4, 32, 3, true, false ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_preload_pc_2_pt_4_f_3_r_32_c_3 < 16, 16, 2, 4, 3, 32, 3, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_preload_pc_2_pt_4_f_3_r_32_c_3 < 16, 16, 2, 4, 3, 32, 3, true, false ><<>>(tex_images, tex_hidacts, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 2) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 1) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, true, false >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, true, false ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n }\n else if (checkCaseBounds == true) {\n if (numFilterColors > 3) {\n if (numFilterColors % 64 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 8, 16, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 8, 16, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 48 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 32, 4, 6, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 4, 6, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 2, 6, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 8, 16, 1, 6, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 32 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 8, 16, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 8, 16, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 8, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors % 16 == 0) {\n if (numFiltersPerGroup % 128 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 32, 4, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 4, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 2, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, true >, cudaFuncCachePreferShared);\n conv_weight_acts_mc_mf_kepler_sw < 4, 16, 1, 4, 32, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, numImgColors, numGroups, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n else if (numFilterColors <= 3) {\n if (numFilterColors == 3) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 3, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 3, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 3, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 3, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 3, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 3, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 2) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 2, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 2, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 2, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 2, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n else if (numFilterColors == 1) {\n if (numFiltersPerGroup % 64 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 2, 4, 32, 1, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 48 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 4, 3, 32, 1, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 32 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 8, 16, 2, 2, 2, 16, 1, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n else if (numFiltersPerGroup % 16 == 0) {\n cudaFuncSetCacheConfig(conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, true, true >, cudaFuncCachePreferShared);\n conv_weight_acts_c_kepler_sw < 16, 16, 2, 16, 1, 32, 1, true, true ><<>>(images_data, hidacts_data, targets_data, numImages, numFilters, numModulesY, numModulesX, imgSizeY, imgSizeX, filterSize, paddingStart, moduleStride, imgStride, sumWidth, scaleTargets, scaleOutput);\n }\n }\n }\n }\n }\n checkCudaErrors(cudaDestroyTextureObject(tex_images));\n checkCudaErrors(cudaDestroyTextureObject(tex_hidacts));\n checkCudaErrors(cudaDeviceSetSharedMemConfig(cudaSharedMemBankSizeFourByte));\n getLastCudaError(\"weightActs: kernel execution failed\");\n}\n\nvoid convWeightActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int filterSize, int paddingStart, int moduleStride, int numImgColors, int numGroups, int partialSum) {\n _weightActs(context, images, hidActs, targets, imgSizeY, numModulesY, numModulesX, filterSize, paddingStart, moduleStride, numImgColors, numGroups, partialSum, 0, 1);\n}\n\nvoid convWeightActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int filterSize, int paddingStart, int moduleStride, int numImgColors, int numGroups, int partialSum,\n float scaleTargets, float scaleOutput) {\n _weightActs(context, images, hidActs, targets, imgSizeY, numModulesY, numModulesX, filterSize, paddingStart, moduleStride, numImgColors, numGroups, partialSum, scaleTargets, scaleOutput);\n}\n\nvoid localWeightActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int filterSize, int paddingStart, int moduleStride, int numImgColors, int numGroups) {\n _weightActs(context, images, hidActs, targets, imgSizeY, numModulesY, numModulesX, filterSize, paddingStart, moduleStride, numImgColors, numGroups, 1, 0, 1);\n}\n\nvoid localWeightActs(caffe2::CUDAContext* context, caffe2::TensorCUDA* images, caffe2::TensorCUDA* hidActs, caffe2::TensorCUDA* targets,\n int imgSizeY, int numModulesY, int numModulesX, int filterSize, int paddingStart, int moduleStride,\n int numImgColors, int numGroups, float scaleTargets, float scaleOutput) {\n _weightActs(context, images, hidActs, targets, imgSizeY, numModulesY, numModulesX, filterSize, paddingStart, moduleStride, numImgColors, numGroups, 1, scaleTargets, scaleOutput);\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/Makefile", "content": "################################################################################\n#\n# Copyright 1993-2012 NVIDIA Corporation. All rights reserved.\n#\n# NOTICE TO USER: \n#\n# This source code is subject to NVIDIA ownership rights under U.S. and \n# international Copyright laws. \n#\n# NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE \n# CODE FOR ANY PURPOSE. IT IS PROVIDED \"AS IS\" WITHOUT EXPRESS OR \n# IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH \n# REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF \n# MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. \n# IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, \n# OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS \n# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE \n# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE \n# OR PERFORMANCE OF THIS SOURCE CODE. \n#\n# U.S. Government End Users. This source code is a \"commercial item\" as \n# that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of \n# \"commercial computer software\" and \"commercial computer software \n# documentation\" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) \n# and is provided to the U.S. Government only as a commercial end item. \n# Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through \n# 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the \n# source code with only those rights set forth herein.\n#\n################################################################################\n\n# Location of the CUDA Toolkit binaries and libraries\nCUDA_INC_PATH = $(CUDA_INSTALL_PATH)/include\nCUDA_BIN_PATH = $(CUDA_INSTALL_PATH)/bin\nCUDA_LIB_PATH = $(CUDA_INSTALL_PATH)/lib64\n\n# Common binaries\nNVCC = $(CUDA_BIN_PATH)/nvcc\nGCC = g++\nAR\t\t\t\t= ar\n\n# CUDA code generation flags\nGENCODE_SM35 := -gencode arch=compute_35,code=sm_35\nGENCODE_FLAGS := $(GENCODE_SM35)\n\nLDFLAGS := -L$(CUDA_LIB_PATH) -lcudart\nCCFLAGS := -m64\nNVCCFLAGS := -m64\n\n# Debug build flags\nifeq ($(dbg),1)\n CCFLAGS += -g\n NVCCFLAGS += -g -G\n DBG := debug\nelse\n DBG := release\n NVCCFLAGS += -O3\n CCFLAGS += -O3\nendif\n\n# Add profiler output\nifeq ($(prof),1)\n\tNVCCFLAGS += --ptxas-options=-v\nendif\n\nTARGETDIR := ./bin/$(DBG)\nOBJDIR := ./obj/$(DBG)\n\n########## USER STUFF ###########\nPYTHON_VERSION=$(shell python -V 2>&1 | cut -d ' ' -f 2 | cut -d '.' -f 1,2)\nMODELNAME := _ConvNet\nLDFLAGS += -lpthread -ljpeg -lpython$(PYTHON_VERSION) -L../util -lutilpy -L../nvmatrix -lnvmatrix -L../cudaconv3 -lcudaconv -lcublas -Wl,-rpath=./util -Wl,-rpath=./nvmatrix -Wl,-rpath=./cudaconv3 \nINCLUDES := -I$(CUDA_INC_PATH) -I $(CUDA_SDK_PATH)/common/inc -I./include -I$(PYTHON_INCLUDE_PATH) -I$(NUMPY_INCLUDE_PATH) \n\nDEFINES := -DNUMPY_INTERFACE\n\nCUFILES\t:= $(shell find . -name \"*.cu\")\nCU_DEPS\t:= $(shell find . -name \"*.cuh\")\nCCFILES\t:= $(shell find . -name \"*.cpp\")\nC_DEPS\t:= $(shell find . -name \"*.h\")\n\nNVCCFLAGS += --compiler-options '-fPIC'\nLDFLAGS += -shared\nCCFLAGS += -fPIC\nTARGET := $(TARGETDIR)/$(MODELNAME).so\n\n################################################################################\n# Set up target and object files\n################################################################################\nOBJS += $(patsubst %.cpp,$(OBJDIR)/%.cpp.o,$(CCFILES))\nOBJS += $(patsubst %.c,$(OBJDIR)/%.c.o,$(CFILES))\nOBJS += $(patsubst %.cu,$(OBJDIR)/%.cu.o,$(CUFILES))\n\n# Target rules\nall: makedirs $(TARGET)\n\n$(OBJDIR)/%.cu.o : %.cu $(CU_DEPS)\n\t$(NVCC) $(DEFINES) $(NVCCFLAGS) $(GENCODE_FLAGS) $(INCLUDES) -o $@ -c $<\n\n$(OBJDIR)/%.cpp.o : %.cpp $(C_DEPS)\n\t$(GCC) $(DEFINES) $(CCFLAGS) $(INCLUDES) -o $@ -c $<\n\n$(TARGET): $(OBJS)\n\t$(GCC) $(CCFLAGS) -o $@ $+ $(LDFLAGS) $(EXTRA_LDFLAGS)\n\tln -sf $(TARGET) .\n\nmakedirs:\n\tmkdir -p $(TARGETDIR)\n\tmkdir -p $(OBJDIR)/src\n\nclean:\n\trm -rf ./obj\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/__init__.py", "content": "" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/actbroadcaster.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef ACTBROADCASTER_CUH_H_\n#define ACTBROADCASTER_CUH_H_\n\n#include \n#include \"streambroadcast.cuh\"\n#include \"copypipeline.cuh\"\n\nclass BroadcastMessage {\npublic:\n enum MESSAGE_TYPE {\n BROADCAST,\n EXIT\n };\nprotected:\n int _srcDevice;\n std::map _mats;\n int _userIdx;\n Queue* _finishQueue;\n MESSAGE_TYPE _type;\n BroadcastMessage(MESSAGE_TYPE type);\npublic:\n BroadcastMessage(std::map mats, int srcDevice, int userIdx, Queue& finishQueue);\n\n int getSrcDevice();\n std::map& getMatrices();\n int getUserIdx();\n Queue& getFinishQueue();\n MESSAGE_TYPE getMessageType();\n};\n\nclass ExitBroadcastMessage : public BroadcastMessage {\npublic:\n ExitBroadcastMessage();\n};\n\nclass ActBroadcaster : public Thread {\nprotected:\n std::map _broadcasters; // src device --> broadcaster\n Queue _messageQueue;\n int _numUsers;\npublic:\n ActBroadcaster(int numUsers, intv& cpus);\n ~ActBroadcaster();\n Queue& getMessageQueue();\n virtual void* run();\n void stop();\n};\n\n\n#endif /* ACTBROADCASTER_CUH_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/convnet.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef CONVNET3\n#define\tCONVNET3\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"../../util/include/queue.h\"\n#include \"../../util/include/thread.h\"\n#include \n#include \"../../util/include/sync.h\"\n#include \"messages.cuh\"\n#include \"streambroadcast.cuh\"\n\n#include \"layer.cuh\"\n#include \"data.cuh\"\n#include \"worker.cuh\"\n#include \"weights.cuh\"\n#include \"pipedispenser.cuh\"\n#include \"timer.cuh\"\n\nclass Worker;\nclass WorkResult;\nclass Layer;\nclass DataLayer;\nclass CostLayer;\nclass ConvNetThread;\nclass StreamBroadcast;\nclass Weights;\n\n// name -> device id -> layer*\ntypedef std::map > NameReplicaLayerMap;\ntypedef std::map NameLayerMap;\n// name -> ReplicaMap\n//typedef std::map ReplicaNameLayerMap;\ntypedef std::vector ConvNetThreadV;\ntypedef std::vector DataLayerVector;\n//typedef std::map ReplicaThreadsMap;\n\nclass ConvNet : public Thread {\nprivate:\n void checkGradient_copyWeightsToGPU(Matrix& weightsCPU, Weights& weights);\nprotected:\n NameReplicaLayerMap _layerMap;\n DataLayerVector _dataLayers;\n // Vector of convnet threads (one thread == one GPU)\n ConvNetThreadV _convNetThreads;\n\n DataProvider* _dp;\n CPUData* _data, *_bufferData;\n int _bufferMinibatchIdx, _bufferPassIdx;\n ThreadSynchronizer* _sync;\n intv _deviceIDs;\n \n Queue _workerQueue;\n Queue _resultQueue;\n Queue _msgQueue;\n \n int _numFwdTerminal;\n std::map _numBwdTerminal; // pass idx -> #terminal\n int _totalPassesDone;\n int _numReplicasMin, _numReplicasMax;\n // For gradient checking\n int _numFailures;\n int _numTests;\n\n // Training progress (between 0 and 1).\n // Used to determine learning rate based on ParameterSchedule.\n double _trainingProgress;\n double _baseErr;\n bool _conserveMem;\n PipeDispenser *_dataCopyPD;\n\n void waitForTerminals(int numMsgs, MESSAGES msg);\n void sendMessage(MESSAGES msg, bool sync);\n void sendMessage(Message* msg, bool sync);\n void findBwdTerminal(Layer& l, std::set& visited, int& terminal, int passIdx);\n void connectReplicas();\n void initDataLayers(PyObjectV* layerList);\n void initGPUThreads(PyObjectV* layerList);\n void connectChildren(PyObject* layerParams);\n void* run();\n void setData(CPUData& data, int passIdx);\n void setDataFromBuffer();\n void setBuffer(CPUData* bufferData, int bufferMinibatchIdx, int bufferPassIdx);\npublic:\n ConvNet(PyObject* layerParams, intv& deviceIDs,\n int minibatchSize, bool conserveMem);\n ~ConvNet();\n void stop();\n \n Queue& getMessageQueue();\n Queue& getWorkerQueue();\n Queue& getResultQueue();\n DataProvider& getDataProvider();\n \n Layer& getLayer(std::string& name, int replicaID);\n void copyToCPU();\n void copyToGPU();\n void updateWeights(int passIdx);\n void reset(int passIdx);\n void reset();\n\n void bprop(int passIdx, PASS_TYPE passType);\n void fprop(int miniIdx, int passIdx, PASS_TYPE passType);\n void fprop(CPUData& data, int passIdx, PASS_TYPE passType);\n\n void setTrainingProgress(double progress);\n double getTrainingProgress() const;\n\n bool checkGradient(const std::string& name, float eps, Weights& weights); \n void checkGradients();\n Cost& getCost();\n Cost& getCost(Cost& cost);\n CPUData& getData(); // Returns last minibatch fpropped\n double getCostValue();\n intv& getDeviceIDs();\n ThreadSynchronizer& getSync();\n void syncWithChildren();\n int getMinibatchSize();\n bool isConserveMemory();\n int getNumReplicasMax();\n int getNumReplicasMin();\n int getNumPasses();\n int getTotalPassesDone();\n PipeDispenser& getDataCopyPD();\n};\n\nclass ConvNetThread : public Thread {\nprotected:\n NameLayerMap _nameLayerMap;\n std::vector _costs;\n ConvNet* _convNet;\n int _deviceID;\n Queue _msgQueue;\n Timer _timer;\n// StreamBroadcast* _weightSynchronizer;\n \n void initCuda();\n virtual void initLayer(PyObject* paramsDict, int replicaID);\n void* run();\npublic:\n ConvNetThread(PyObjectV* layerList, int deviceID, int deviceIdx, ConvNet* convNet);\n ~ConvNetThread();\n \n NameLayerMap& getLayerMap();\n int getDeviceID();\n \n ConvNet& getConvNet();\n \n Queue& getMessageQueue();\n std::vector& getCostLayers();\n// StreamBroadcast& getWeightSynchronizer();\n \n Cost& getCost();\n Layer& getLayer(std::string& name);\n void startTimer();\n double stopTimer();\n};\n\n#endif\t/* CONVNET */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/copypipeline.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef COPYPIPELINE_CUH_\n#define COPYPIPELINE_CUH_\n\n#include \n#include \"../../util/include/thread.h\"\n#include \"../../util/include/queue.h\"\n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"util.cuh\"\n\n#define COPY_MIN_CHUNK_SIZE (1<<18) // 256k\n#define COPY_MAX_CHUNKS 16\n#define COPY_MIN_CHUNKS 2\n\nclass CopyPeer;\nclass CopySource;\nclass ICopySegment;\nclass IBroadcastNetwork;\n\nclass CopyMessage {\nprotected:\n std::map* _mats;\n float _scaleSource, _scaleTargets;\npublic:\n enum COPY_MESSAGE_TYPE {\n COPY_CHUNK,\n COPY_START,\n EXIT\n };\n CopyMessage(COPY_MESSAGE_TYPE msgType, float scaleSource, float scaleTargets, std::map& mats)\n : _msgType(msgType), _scaleSource(scaleSource), _scaleTargets(scaleTargets), _mats(&mats) {\n }\n CopyMessage(COPY_MESSAGE_TYPE msgType)\n : _msgType(msgType), _scaleSource(0), _scaleTargets(0), _mats(NULL) {\n }\n inline COPY_MESSAGE_TYPE getType() const {\n return _msgType;\n }\n inline NVMatrix& getMatrix(int deviceID) const {\n return *_mats->at(deviceID);\n }\n inline std::map& getMatrices() const {\n return *_mats;\n }\n inline float getScaleSource() const {\n return _scaleSource;\n }\n inline float getScaleTargets() const {\n return _scaleTargets;\n }\nprotected:\n COPY_MESSAGE_TYPE _msgType;\n};\n\nclass CopyChunkMessage : public CopyMessage {\nprotected:\n int _chunkIdx;\n int _chunkSize;\n int _numChunks;\npublic:\n CopyChunkMessage(int chunkIdx, int chunkSize, int numChunks, float scaleSource, float scaleTargets, std::map& mats)\n : _chunkIdx(chunkIdx), _chunkSize(chunkSize), _numChunks(numChunks), CopyMessage(COPY_CHUNK, scaleSource, scaleTargets, mats) {\n }\n\n inline int getChunkIdx() const {\n return _chunkIdx;\n }\n inline int getChunkSize() const {\n return _chunkSize;\n }\n inline int getNumChunks() const {\n return _numChunks;\n }\n};\n\nclass CopyStartMessage : public CopyMessage {\npublic:\n CopyStartMessage(float scaleSource, float scaleTargets, std::map& mats) : CopyMessage(COPY_START, scaleSource, scaleTargets, mats) {\n }\n};\n\nclass ICopySegment : public Thread {\nprotected:\n int _deviceID, _execDeviceID;\n cudaStream_t _stream;\n ICopySegment* _prev;\n std::vector _next;\n Queue _queue;\n Queue* _finishQueue;\n HostNVMatrix _hmat;\n IBroadcastNetwork* _parent;\n\n NVMatrix& getChunk(NVMatrix& mat, int chunkSize, int chunkIdx);\n void* run();\n virtual bool processMessage(CopyMessage& msg) = 0;\n\npublic:\n ICopySegment(IBroadcastNetwork& parent, int deviceID, Queue* finishQueue);\n virtual ~ICopySegment();\n inline NVMatrix& getMatrix(CopyMessage& msg);\n Queue& getQueue();\n inline int getDeviceID();\n void addPrev(ICopySegment& c);\n void addNext(CopyPeer& c);\n bool isTerminal() const;\n virtual bool isSource() const = 0;\n};\n\nclass CopySource : public ICopySegment {\nprotected:\n bool processMessage(CopyMessage& msg);\npublic:\n CopySource(IBroadcastNetwork& parent, int deviceID);\n inline bool isSource() const;\n};\n\nclass CopyPeer : public ICopySegment {\nprotected:\n bool processMessage(CopyMessage& msg);\npublic:\n CopyPeer(IBroadcastNetwork& parent, int deviceID, Queue* finishQueue);\n inline bool isSource() const;\n};\n\nclass IBroadcastNetwork {\nprotected:\n Queue _finishQueue;\n CopySource* _src;\n std::vector _peers;\n int _srcDeviceID, _numTerminal;\n bool _constructed;\n std::set _devices;\n std::pair,std::vector > makeGPULists();\n\n void makePeers(std::pair,std::vector >& gpus);\n virtual void makeConnections() = 0;\n virtual void _broadcast(std::map& mats, float scaleSource, float scaleTargets);\n IBroadcastNetwork(std::set& devices, int srcDeviceID, int numTerminal);\npublic:\n virtual IBroadcastNetwork& construct();\n virtual ~IBroadcastNetwork();\n\n virtual void broadcast(std::map& mats);\n int getSourceDeviceID() const;\n static IBroadcastNetwork& make(std::set devices, int srcDeviceID);\n};\n\nclass ISafeBroadcastNetwork : public IBroadcastNetwork {\nprotected:\n ISafeBroadcastNetwork(std::set& devices, int srcDeviceID, int numTerminal);\npublic:\n virtual void broadcast(std::map& mats, float scaleSource, float scaleTargets);\n virtual ISafeBroadcastNetwork& construct();\n static ISafeBroadcastNetwork& make(std::set devices, int srcDeviceID);\n};\n\nclass NullBroadcaster : public ISafeBroadcastNetwork {\nprotected:\n NullBroadcaster(std::set& devices, int srcDeviceID);\n void makeConnections();\npublic:\n NullBroadcaster& construct();\n void broadcast(std::map& mats, float scaleSource, float scaleTargets);\n void broadcast(std::map& mats);\n friend class IBroadcastNetwork;\n friend class ISafeBroadcastNetwork;\n};\n\n/*\n * This one goes to host and then to targets.\n */\nclass NaiveBroadcaster : public ISafeBroadcastNetwork {\nprotected:\n NaiveBroadcaster(std::set& devices, int srcDeviceID);\n void makeConnections();\n friend class IBroadcastNetwork;\n friend class ISafeBroadcastNetwork;\n};\n\nclass EightGPUBroadcaster1 : public IBroadcastNetwork {\nprotected:\n EightGPUBroadcaster1(std::set& devices, int srcDeviceID);\n void makeConnections();\n friend class IBroadcastNetwork;\n};\n\nclass TwoPeeringGPUsBroadcaster : public ISafeBroadcastNetwork {\nprotected:\n int _tgtDeviceID;\n cudaStream_t _tgtStream;\n void makeConnections();\n void resetDeviceID(int d);\n void _broadcast(std::map& mats, float scaleSource, float scaleTargets);\npublic:\n TwoPeeringGPUsBroadcaster(std::set& devices, int srcDeviceID);\n ~TwoPeeringGPUsBroadcaster();\n ISafeBroadcastNetwork& construct();\n friend class IBroadcastNetwork;\n friend class ISafeBroadcastNetwork;\n};\n\n#endif /* COPYPIPELINE_CUH_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/cost.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef COST_CUH\n#define\tCOST_CUH\n\n#include \n#include \n#include \n\n#include \"layer.cuh\"\n#include \"util.cuh\"\n\nclass CostLayer;\n\n/*\n * Wrapper for dictionary mapping cost name to vector of returned values.\n */\nclass Cost {\nprotected:\n std::map _numCases;\n CostMap _costMap;\n CostCoeffMap _costCoeffMap;\n std::map& getNumCasesMap();\npublic:\n Cost();\n Cost(std::vector& costs);\n doublev& operator [](const std::string s);\n CostMap& getCostMap();\n CostCoeffMap& getCostCoeffMap();\n int getNumCases();\n /*\n * Returns sum of first values returned by all the CostLayers, weighted by the cost coefficients.\n */\n double getValue();\n Cost& operator += (Cost& er);\n virtual ~Cost();\n void print();\n};\n\n\n#endif\t/* COST_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/data.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef DATA_CUH\n#define\tDATA_CUH\n\n#include \n#include \n#include \"util.cuh\"\n\nclass CPUData {\nprotected:\n MatrixV* _data;\n void assertDimensions() {\n assert(_data->size() > 0);\n for (int i = 1; i < _data->size(); i++) {\n assert(_data->at(i-1)->getNumCols() == _data->at(i)->getNumCols());\n if (_data->at(i-1)->isTrans() != _data->at(i)->isTrans() && _data->at(i)->getNumElements() < 2) {\n _data->at(i)->setTrans(_data->at(i-1)->isTrans());\n }\n assert(_data->at(i-1)->isTrans() == _data->at(i)->isTrans());\n }\n assert(_data->at(0)->getNumCols() > 0);\n }\npublic:\n typedef typename MatrixV::iterator T_iter;\n // Cases in columns, but array may be transposed\n // (so in memory they can really be in rows -- in which case the array is transposed\n // during the copy to GPU).\n CPUData(PyObject* pyData) {\n _data = getMatrixV(pyData);\n assertDimensions();\n }\n \n CPUData(MatrixV* data) : _data(data) {\n assertDimensions();\n }\n\n ~CPUData() {\n for (T_iter it = _data->begin(); it != _data->end(); ++it) {\n delete *it;\n }\n delete _data;\n }\n \n Matrix& operator [](int idx) const {\n return *_data->at(idx);\n }\n \n int getSize() const {\n return _data->size();\n }\n \n MatrixV& getData() const {\n return *_data;\n }\n \n Matrix& getData(int i) const {\n return *_data->at(i);\n }\n \n bool isTrans() const {\n return _data->at(0)->isTrans();\n }\n\n int getNumCases() const {\n return _data->at(0)->getNumCols();\n }\n};\n\nclass DataProvider {\nprotected:\n CPUData* _hData;\n NVMatrixV _data;\n int _minibatchSize;\npublic:\n DataProvider(int minibatchSize);\n void setData(CPUData&);\n void clearData();\n CPUData& getMinibatch(int idx);\n CPUData& getDataSlice(int startCase, int endCase);\n int getNumMinibatches();\n int getMinibatchSize();\n int getNumCases();\n};\n\n#endif\t/* DATA_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/gradreducer.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef GRADREDUCER_CUH_\n#define GRADREDUCER_CUH_\n\n#include \n#include \n#include \"streambroadcast.cuh\"\n#include \"reducepipeline.cuh\"\n#include \"layer.cuh\"\n#include \"util.cuh\"\n\nclass StreamBroadcast;\nclass Layer;\n\n#define ACT_GRAD_REDUCER_EXIT (1 << 16)\n\n//class ReduceMessage {\n// ReduceMessage();\n// ReduceMessage(bool exit);\n//};\n\nclass IActGradReducer : public Thread {\nprotected:\n Layer* _parent;\n Queue _finishQueue;\n int _numExpectedMsgsTotal;\n std::map _numExpectedMsgs; // map from device id -> num expected msgs\n\n void* run();\n virtual bool reduce() = 0;\n virtual void reset() = 0;\npublic:\n IActGradReducer(Layer& parent, std::map numExpectedMsgs);\n virtual ~IActGradReducer();\n int waitForFinish();\n virtual void enqueueReduction(int deviceID) = 0;\n virtual void stop() = 0;\n static IActGradReducer& makeGradReducer(Layer& parent, std::map numExpectedMsgs);\n};\n\nclass SequentialActGradReducer : public IActGradReducer {\nprotected:\n\n std::map _numReceivedMsgs; // map from device id -> num received msgs\n\n std::map* > _messageQueues;\n intv _deviceIDs;\n StreamBroadcast* _broadcaster;\n bool reduce();\n void reset();\npublic:\n SequentialActGradReducer(Layer& parent, std::map numExpectedMsgs);\n ~SequentialActGradReducer();\n void enqueueReduction(int deviceID);\n void stop();\n};\n\nclass ParallelActGradReducer : public IActGradReducer {\nprotected:\n IEightGPUReducer* _reducer;\n int _numReceivedMsgs;\n float _scaleTarget;\n Queue _messageQueue;\n bool reduce();\n void reset();\npublic:\n ParallelActGradReducer(Layer& parent, std::map numExpectedMsgs);\n void enqueueReduction(int deviceID);\n void stop();\n};\n\n\n#endif /* GRADREDUCER_CUH_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/jpeg.h", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef JPEG_MAIN_H\n#define JPEG_MAIN_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n//#include \n#include \"../../util/include/thread.h\"\n#include \"../../util/include/matrix.h\"\n\n#ifndef DIVUP\n#define DIVUP(x, y) (((x) + (y) - 1) / (y))\n#endif\n\n#define NUM_JPEG_DECODER_THREADS 4\n\n\nclass DecoderThread : public Thread {\n protected:\n PyObject* _pyList;\n Matrix* _target;\n int64 _start_img, _end_img;\n int64 _img_size, _inner_size, _inner_pixels;\n bool _test, _multiview;\n\n unsigned char* _decodeTarget;\n int64 _decodeTargetSize;\n unsigned int _rseed;\n\n void* run();\n void decodeJpeg(int idx, int& width, int& height);\n double randUniform();\n double randUniform(double min, double max);\n void crop(int64 i, int64 width, int64 height, bool flip);\n virtual void crop(int64 i, int64 src_width, int64 src_height, bool flip, int64 crop_start_x, int64 crop_start_y);\n public:\n DecoderThread(PyObject* pyList, Matrix& target, int start_img, int end_img, int img_size, int inner_size, bool test, bool multiview);\n virtual ~DecoderThread();\n};\n\n#endif // JPEG_MAIN_H\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/layer.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef LAYER_CUH\n#define LAYER_CUH\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n//#include \"experimental/akrizhevsky/g3/mactruck-gpu-tests/gpu_util.cuh\"\n\n#include \"weights.cuh\"\n#include \"convnet.cuh\"\n#include \"cost.cuh\"\n#include \"neuron.cuh\"\n#include \"data.cuh\"\n#include \"layer_kernels.cuh\"\n#include \"streambroadcast.cuh\"\n#include \"actbroadcaster.cuh\"\n#include \"gradreducer.cuh\"\n#include \"util.cuh\"\n#include \"timer.cuh\"\n#include \"memorysource.cuh\"\n\nclass Cost;\nclass ConvNet;\nclass ConvNetThread;\nclass CostLayer;\nclass DataLayer;\nclass Layer;\nclass ActBroadcaster;\nclass BroadcastMessage;\nclass IActGradReducer;\nclass Weights;\nclass WeightList;\ntypedef std::vector LayerV;\n\nclass BinomialCrossEntOperator {\nprotected:\n float _posWeight;\npublic:\n BinomialCrossEntOperator(float posWeight) : _posWeight(posWeight) {\n }\n __device__ inline float operator()(const float t, const float y) const {\n return _posWeight * t * safelog(y) + (1.0f - t) * safelog(1.0f - y);\n }\n};\n\nclass CrossEntOperator {\nprotected:\n float _posWeight;\npublic:\n CrossEntOperator(float posWeight) : _posWeight(posWeight) {\n }\n __device__ inline float operator()(const float t, const float y) const {\n return _posWeight * t * safelog(y);\n }\n};\n\n/*\n * Abstract layer.\n */\nclass Layer {\nprotected:\n ConvNetThread* _convNetThread;\n\n // This is a vector[#layers_next]\n std::vector _next;\n // This is a vector[#replicas_prev][#layers_prev]\n std::map > _prev;\n\n int _rcvdFInputMsgs;\n std::map _numComputedActsGrads;\n int _rcvdBInputMsgs;\n int _numOutputs;\n std::map _inputs; // input idx -> matrix\n std::map _memSrcActs; // device id -> memory source\n std::map _memSrcActsGrad; // device id -> memory source\n\n bool _gradConsumer, _foundGradConsumers, _trans;\n std::map _bwdTerminal; // One bool per pass\n int _numGradProducersNext;\n int _actsTarget, _actsGradTarget;\n std::string _name, _type;\n intv _nextDeviceIDs, _prevDeviceIDs;\n HostNVMatrix _hostMemFwd;\n\n // New replica-related stuff:\n std::map _replicas; // NOTE: a layer is its own sibling, too\n // Previous layers sorted by device ID, in reverse order in which they are procesed by\n // sequential grad reducer. map from replica -> device id -> layers\n std::map > > _prevByDevice;\n std::map _inputIndices;\n int _replicaID;\n int _numReplicas;\n int _numReplicasPrev, _numReplicasNext;\n\n Queue _broadcastFinishQueue;\n Queue _reductionFinishQueue;\n ActBroadcaster* _actBroadcaster;\n IActGradReducer* _gradReducer;\n Timer _timer;\n bool _initialized;\n\n virtual void fpropNext(PASS_TYPE passType, int passIdx);\n virtual void truncBwdActs(); \n virtual void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) = 0;\n \n virtual void bpropCommon(NVMatrix& v, int replicaIdx, PASS_TYPE passType) {\n // Do nothing by default\n }\n virtual void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(!isGradProducer()); // Only do nothing if not grad producer\n }\n virtual void fpropCommon(PASS_TYPE passType) {\n\n }\n void bpropActsCall(NVMatrix& v, PASS_TYPE passType, int replicaIdx, int inputIdx);\n\n ActBroadcaster& getActBroadcaster();\n IActGradReducer& getGradReducer();\n int getInputIdx(std::string& parentName);\n void setInputIdx(std::string& parentName, int idx);\n\npublic:\n static bool _saveActsGrad, _saveActs;\n \n Layer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans);\n virtual ~Layer();\n \n virtual bool fprop(PASS_TYPE passType, int passIdx);\n void fprop(NVMatrix& v, int inpIdx, PASS_TYPE passType, int passIdx);\n virtual void fprop(std::map& v, PASS_TYPE passType, int passIdx);\n virtual void bprop(PASS_TYPE passType, int passIdx);\n virtual void bprop(NVMatrix& v, PASS_TYPE passType, int passIdx);\n virtual void reset();\n virtual void resetPassIdx();\n int getNumCases(NVMatrix& v);\n int& getNumComputedActsGrads(int deviceID);\n int incRcvdBInputMsgs();\n bool isGradConsumer();\n bool hasGradProducerNext(std::string& layerName);\n // Does this layer produce a gradient for any layer?\n virtual bool isGradProducer();\n // Does this layer produce a gradient for layer of given name?\n virtual bool isGradProducer(std::string& layerName);\n std::string& getName();\n std::string& getType();\n virtual void addNext(Layer& l);\n virtual void addPrev(Layer& l, int replicaIdx);\n virtual void addReplica(Layer& l);\n std::map >& getPrev();\n std::vector& getNext();\n virtual NVMatrix& getActs();\n virtual NVMatrix& getActs(int deviceID);\n virtual NVMatrix& getActs(int deviceID, int numCases);\n virtual NVMatrix& getActsGrad();\n virtual NVMatrix& getActsGrad(int deviceID);\n virtual std::map getAllActs();\n virtual std::map getAllActsGrads();\n virtual bool postInit();\n int getDeviceID();\n ConvNetThread& getConvNetThread();\n cudaStream_t getStream();\n void syncStream();\n void setBwdTerminal(int passIdx);\n // Do nothing if this layer has no weights\n virtual bool updateWeights() {\n return false;\n }\n virtual bool constrainWeights() {\n return false;\n }\n virtual void checkGradient() {\n }\n virtual void copyToCPU() {\n }\n virtual void copyToGPU() {\n }\n intv& getNextDeviceIDs() {\n return _nextDeviceIDs;\n }\n\n int getReplicaID();\n int getNumReplicas();\n int getNumSiblingReplicas();\n int getNumReplicasPrev();\n int getNumReplicasNext();\n int getNumOutputs();\n void setMemorySourceActs(int deviceID, MemoryView& mem);\n void setMemorySourceActsGrad(int deviceID, MemoryView& mem);\n MemoryView& getMemorySourceActs(int deviceID);\n MemoryView& getMemorySourceActsGrad(int deviceID);\n int getFwdActiveInputReplicaIdx(int passIdx);\n int getBwdActiveInputReplicaIdx(int passIdx);\n int getFwdActiveReplicaIdx(int passIdx);\n int getNumLayersPrev();\n virtual int getNumInputReplicas();\n int getNumExpectedBwdMsgs();\n int getNumExpectedFwdMsgs();\n int getReplicaIdx();\n int getActivePassPeriod();\n int getNumGradProducersNext();\n virtual ConvNet& getConvNet();\n};\n\nclass TwoDLayerInterface {\nprotected:\n int _channels, _imgSize, _imgPixels;\npublic:\n TwoDLayerInterface(PyObject* paramsDict);\n};\n\nclass NeuronLayer : public Layer {\nprotected:\n Neuron* _neuron;\n std::string _neuronType;\n \n virtual void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n virtual void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n virtual bool bpropSpecial(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n class CrossEntLogisticGradientOperator {\n private:\n float _coeff, _posWeight;\n public:\n CrossEntLogisticGradientOperator(float coeff, float posWeight) : _coeff(coeff), _posWeight(posWeight) {\n }\n __device__ inline float operator()(const float y, const float t) const {\n return _coeff * (_posWeight * t * (1.0f - y) + (t - 1.0f) * y);\n }\n };\n NeuronLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n ~NeuronLayer();\n std::string& getNeuronType();\n};\n\nclass WeightLayer : public Layer {\nprotected:\n WeightList* _weights;\n Weights *_biases;\n NVMatrix _norm2;\n float _wStep, _bStep;\n int _weightUpdatePassPeriod;\n void fpropCommon(PASS_TYPE passType);\n void bpropCommon(NVMatrix& v, int replicaIdx, PASS_TYPE passType);\n virtual void bpropBiases(NVMatrix& v, PASS_TYPE passType) = 0;\n virtual void bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType) = 0;\n virtual void _constrainWeights();\n virtual float getGradScale(int inpIdx, PASS_TYPE passType);\n virtual float getIncScale(int inpIdx, PASS_TYPE passType);\n virtual float getBGradScale(PASS_TYPE passType);\n virtual float getBIncScale();\n virtual NVMatrix& getGradTarget(int inpIdx);\n NVMatrix& getWeightMatrix(PASS_TYPE passType, int inpIdx);\n NVMatrix& getBiasMatrix(PASS_TYPE passType);\npublic:\n WeightLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans, bool useGrad);\n virtual ~WeightLayer();\n virtual bool updateWeights();\n virtual bool constrainWeights();\n virtual void copyToCPU();\n virtual void copyToGPU();\n virtual void checkGradient();\n Weights& getWeights(int idx);\n void addReplica(Layer& l);\n virtual bool postInit();\n};\n\nclass FCLayer : public WeightLayer {\nprotected:\n virtual void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n virtual void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n virtual void bpropBiases(NVMatrix& v, PASS_TYPE passType);\n virtual void bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType);\n virtual void _constrainWeights();\npublic:\n FCLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool useGrad);\n FCLayer();\n};\n\nclass SplitFCLayer : public FCLayer {\nprotected:\n int _numParts;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n// void bpropBiases(NVMatrix& v, PASS_TYPE passType);\n void bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType);\n void splitWeights();\npublic:\n SplitFCLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool useGrad);\n};\n\nclass SoftmaxLayer : public Layer {\nprotected:\n bool _doUpperGrad;\n NVMatrix _max, _sum;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n SoftmaxLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n void setDoUpperGrad(bool b);\n};\n\nclass ConcatenationLayer : public Layer {\nprotected:\n intv* _copyOffsets;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n ConcatenationLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n virtual ~ConcatenationLayer();\n};\n\nclass PassThroughLayer : public Layer {\nprotected:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n PassThroughLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n virtual bool postInit();\n};\n\nclass EltwiseSumLayer : public Layer {\nprotected:\n floatv* _coeffs;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n EltwiseSumLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n ~EltwiseSumLayer();\n};\n\nclass EltwiseMaxLayer : public Layer {\nprotected:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n EltwiseMaxLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass SumLayer : public Layer {\nprotected:\n int _stride;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n SumLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass DataCopyMessage {\npublic:\n enum MESSAGE_TYPE {\n COPY,\n EXIT\n };\nprotected:\n CPUData* _cpuData;\n int _passIdx;\n bool _other;\n DataCopyMessage::MESSAGE_TYPE _type;\n DataCopyMessage(DataCopyMessage::MESSAGE_TYPE type) : _cpuData(NULL), _other(false), _passIdx(0), _type(type) {\n }\npublic:\n DataCopyMessage(CPUData& cpuData, bool other, int passIdx) : _cpuData(&cpuData), _other(other), _passIdx(passIdx), _type(DataCopyMessage::COPY) {\n }\n \n CPUData& getData() const {\n return *_cpuData;\n }\n \n int getPassIdx() const {\n return _passIdx;\n }\n \n bool isOther() const {\n return _other;\n }\n\n DataCopyMessage::MESSAGE_TYPE getType() {\n return _type;\n }\n};\n\nclass DataCopyExitMessage : public DataCopyMessage {\npublic:\n DataCopyExitMessage() : DataCopyMessage(DataCopyMessage::EXIT) {\n }\n};\n\nclass DataCopyThread;\n\nclass DataLayer : public Layer {\nprotected:\n bool _useBuffer;\n int _dataIdx;\n ConvNet* _convNet;\n// std::map _outputs2; // Buffer for copying data during computation\n std::map _memSrcActs2; // // Buffer for copying data during computation\n std::map _copyStreams;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n Queue _copyFinishQueue;\n DataCopyThread* _copier;\n bool _outstandingCopyRequest;\n int _start, _end;\n \npublic:\n void fprop(PASS_TYPE passType, int passIdx, bool fromBuffer);\n DataLayer(ConvNet* convNet, PyObject* paramsDict, int replicaID);\n ~DataLayer();\n NVMatrix& getActs(int deviceID);\n// NVMatrix& getActs(int deviceID, bool other);\n NVMatrix& getActs(int deviceID, bool other, int numCases);\n bool isGradProducer();\n void toggleBuffer(int passIdx);\n void copyData(CPUData& data, bool other, int passIdx);\n bool postInit();\n ConvNet& getConvNet();\n int getNumInputReplicas();\n cudaStream_t getCopyStream(int deviceID);\n Queue& getCopyFinishQueue() {\n return _copyFinishQueue;\n }\n void waitForCopyFinish();\n int getDataIdx() const {\n return _dataIdx;\n }\n int getStart() const {\n return _start;\n }\n int getEnd() const {\n return _end;\n }\n};\n\n\nclass DataCopyThread : public Thread {\nprotected:\n DataLayer* _parent;\n Queue _queue;\n HostNVMatrix _hostMemFwd;\n Timer _requestTimer;\n int _sleepUsec;\n virtual void* run();\n \npublic:\n DataCopyThread(DataLayer& parent, intv& cpus);\n Queue& getQueue();\n void stop();\n};\n\n\nclass LocalLayer : public WeightLayer {\nprotected:\n intv* _padding, *_stride, *_filterSize, *_channels, *_imgSize, *_groups;\n intv* _imgPixels, *_filterPixels, *_filterChannels;\n int _modulesX, _modules, _numFilters;\n \npublic:\n LocalLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool useGrad);\n virtual ~LocalLayer();\n};\n\nclass ConvLayer : public LocalLayer {\nprotected:\n int _sumWidth;\n bool _sharedBiases;\n floatv* _weightContrastNormMin, *_weightContrastNormMax;\n NVMatrix _weightGradTmp;\n\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n void bpropBiases(NVMatrix& v, PASS_TYPE passType);\n void bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType);\n void truncBwdActs();\n void _constrainWeights();\n\npublic:\n ConvLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n virtual ~ConvLayer();\n}; \n\nclass LocalUnsharedLayer : public LocalLayer {\nprotected:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n void bpropBiases(NVMatrix& v, PASS_TYPE passType);\n void bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType);\n void _constrainWeights();\npublic:\n LocalUnsharedLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n}; \n\nclass PoolLayer : public Layer, public TwoDLayerInterface {\nprotected:\n int _sizeX, _start, _stride, _outputsX;\n std::string _pool;\npublic:\n PoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans);\n \n static PoolLayer& make(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n}; \n\nclass AvgPoolLayer : public PoolLayer {\nprotected:\n bool _sum;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n AvgPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n}; \n\nclass MaxPoolLayer : public PoolLayer {\nprotected:\n bool _abs;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n MaxPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool abs);\n};\n\nclass CrossMapPoolLayer : public Layer, public TwoDLayerInterface {\nprotected:\n int _size, _start, _stride, _outputs;\n std::string _pool;\npublic:\n CrossMapPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans);\n\n static CrossMapPoolLayer& make(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass CrossMapMaxPoolLayer : public CrossMapPoolLayer {\nprotected:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n CrossMapMaxPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass RandomScaleLayer : public Layer, public TwoDLayerInterface {\nprotected:\n int _tgtSize, _minScaledSize;\n float _maxScale; // should be >= 1\n NVMatrix _rescaledActs;\n std::vector _scaleProbs;\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n \n RandomScaleLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass CropLayer : public Layer, public TwoDLayerInterface {\nprotected:\n int _tgtSize, _startX, _startY;\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n\n CropLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass NailbedLayer : public Layer, public TwoDLayerInterface {\nprotected:\n int _start, _stride, _outputsX;\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n \n NailbedLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass GaussianBlurLayer : public Layer, public TwoDLayerInterface {\nprotected:\n Matrix* _hFilter;\n NVMatrix _filter;\n NVMatrix _actGradsTmp;\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n void copyToGPU();\n \n GaussianBlurLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n ~GaussianBlurLayer();\n};\n\nclass HorizontalReflectionLayer : public Layer, public TwoDLayerInterface {\nprotected:\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n \n HorizontalReflectionLayer(ConvNetThread* convNet, PyObject* paramsDict, int replicaID);\n};\n\nclass ResizeLayer : public Layer, public TwoDLayerInterface {\nprotected:\n float _scale;\n int _tgtSize;\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n\n ResizeLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass DropoutLayer : public Layer {\nprotected:\n bool _enable;\n float _keep;\n NVMatrix _keepMask;\npublic:\n virtual void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n virtual void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n void truncBwdActs();\n DropoutLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n class DropoutSmallerThanOperator {\n private:\n float _keep, _scale;\n public:\n DropoutSmallerThanOperator(float keep) : _keep(keep), _scale(1.0f/keep) {\n }\n __device__ inline float operator()(const float x) const {\n return (x < _keep) * _scale;\n }\n };\n};\n\nclass Dropout2Layer : public DropoutLayer {\nprotected:\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n Dropout2Layer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass RGBToYUVLayer : public Layer {\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n\n RGBToYUVLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass RGBToLABLayer : public Layer {\nprotected:\n bool _center;\npublic:\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n\n RGBToLABLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass ResponseNormLayer : public Layer, public TwoDLayerInterface {\nprotected:\n int _size;\n float _scale, _pow;\n float _minDiv;\n NVMatrix _denoms;\n\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n void truncBwdActs();\npublic:\n ResponseNormLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n}; \n\nclass CrossMapResponseNormLayer : public ResponseNormLayer {\nprotected:\n bool _blocked;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n CrossMapResponseNormLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n}; \n\nclass ContrastNormLayer : public ResponseNormLayer {\nprotected:\n NVMatrix _meanDiffs;\n \n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\n void truncBwdActs();\npublic:\n ContrastNormLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass CostLayer : public Layer {\nprotected:\n float _coeff;\n doublev _costv;\n NVMatrix _tmpbuf; // For error accumulation\n int _numCases; // number of cases that the values in _costv were computed on\n bool _aggregated;\n void fpropCommon(PASS_TYPE passType);\npublic:\n CostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans);\n void bprop(NVMatrix& v, PASS_TYPE passType, int passIdx);\n bool fprop(PASS_TYPE passType, int passIdx);\n \n int getNumCases();\n virtual doublev& getCost();\n float getCoeff();\n bool isGradProducer();\n void setSendTerminalMessages(bool send);\n void resetPassIdx();\n \n static CostLayer& make(ConvNetThread* convNetThread, PyObject* paramsDict, std::string& type, int replicaID);\n};\n\n/*\n * Input 0: labels\n * Input 1: softmax outputs\n */\nclass CrossEntCostLayer : public CostLayer {\nprotected:\n NVMatrix _trueLabelLogProbs, _correctProbs;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n CrossEntCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\n/*\n * Input 0: labels\n * Input 1: softmax outputs\n */\nclass LogregCostLayer : public CostLayer {\nprotected:\n NVMatrix _trueLabelLogProbs, _correctProbs, _topkProbs;\n std::map _probsAccum; // input replica idx -> nvmatrix\n NVMatrix _maxProbs;\n std::map _numAccumed; // input replica idx -> int\n int _topk;\n bool _doCompute;\n virtual void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n LogregCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n NVMatrix& getProbsAccum(int replicaIdx);\n};\n\n/*\n * Input 0: labels\n * Input 1: logistic outputs\n */\nclass BinomialCrossEntropyCostLayer : public CostLayer {\nprotected:\n bool _computeSoftmaxErrorRate;\n NVMatrix _tmpProbs, _tmpVec, _correctProbs;\n float _posWeight;\n virtual void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n BinomialCrossEntropyCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n float getPosWeight();\n\n // Only for use with non-logistic units\n class BinomialCrossEntGradientOperator {\n private:\n float _coeff, _posWeight;\n public:\n BinomialCrossEntGradientOperator(float coeff, float posWeight) : _coeff(coeff), _posWeight(posWeight) {\n }\n __device__ inline float operator()(const float t, const float y) const {\n return _coeff * (_posWeight * __fdividef(t, y) + __fdividef(t - 1.0f, 1.0f - y));\n }\n };\n};\n\n/*\n * Input 0: labels\n * Input 1: logistic outputs\n */\nclass DetectionCrossEntropyCostLayer : public BinomialCrossEntropyCostLayer {\nprotected:\n Matrix _hNumPositive, _hNumTruePositive, _hNumDeclaredPositive;\n NVMatrix _numPositive, _numTrueNegative, _numTruePositive, _numDeclaredPositive;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\npublic:\n DetectionCrossEntropyCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\nclass SumOfSquaresCostLayer : public CostLayer {\nprotected:\n NVMatrix _tmp;\n void fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx);\n void bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType);\npublic:\n SumOfSquaresCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID);\n};\n\n#endif /* LAYER_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/layer_kernels.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef LAYER_KERNELS_CUH\n#define\tLAYER_KERNELS_CUH\n\n#include \n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n\n#define LOGREG_GRAD_THREADS_X 32\n#define LOGREG_GRAD_THREADS_Y 4\n\n#define LOGREG_ERR_THREADS_X 128\n#define LOGREG_ERR_THREADS_Y 1\n\n__device__ inline float safelog(const float x) {\n return x > 0.0f ? __logf(x) : -50.0f;\n}\n\n// The input matrix here is the squared norm.\n// This replaces the squared norm with:\n// 1 if it is below the threshold given by norm2\n// norm/sqrt(a) otherwise -- i.e. the desired norm (not squared)\nclass MaxWeightConstraintOperator {\nprivate:\n float _norm, _norm2;\npublic:\n MaxWeightConstraintOperator(float norm) : _norm(norm), _norm2(norm*norm) {\n }\n __device__ inline float operator()(const float a) const {\n return a > _norm2 ? __fdividef(_norm, sqrtf(a)) : 1.0f;\n }\n};\n\nclass HardWeightConstraintOperator {\nprivate:\n float _norm, _norm2;\npublic:\n HardWeightConstraintOperator(float norm) : _norm(norm), _norm2(norm*norm) {\n }\n __device__ inline float operator()(const float a) const {\n return __fdividef(_norm, sqrtf(a));\n }\n};\n\nclass WeightContrastNormOperator {\nprivate:\n float _min, _max, _scale;\npublic:\n WeightContrastNormOperator(float min, float max, float scale) : _min(min), _max(max), _scale(scale) {\n }\n __device__ inline float operator()(float a) const {\n a = sqrtf(a) * _scale;\n return a < _min ? __fdividef(_min, a) : a > _max ? __fdividef(_max, a) : 1.0f;\n }\n};\n\nvoid computeCrossEntCost(NVMatrix& labels, NVMatrix& probs, NVMatrix& labelLogProbs_out, NVMatrix& correctProbs_out);\nvoid computeCrossEntGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff);\nvoid computeSoftmaxGrad(NVMatrix& acts, NVMatrix& actsGrad, NVMatrix& target, float scaleTarget, float scaleGrad);\n\nvoid computeLogregCost(NVMatrix& labels, NVMatrix& probs, NVMatrix& maxProbs, NVMatrix& labelLogProbs_out, NVMatrix& correctProbs_out);\nvoid computeLogregGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff);\n\n\n// Numerical stability optimization: this routine combines computeLogregGrad with computeSoftmaxGrad\n// to avoi dividing and then multiplying by quantities that may be near zero.\nvoid computeCrossEntSoftmaxGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff);\nvoid computeLogregSoftmaxGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff);\nvoid computeEltwiseMaxGrad(NVMatrix& actGrad, NVMatrix& input, NVMatrix& output, NVMatrix& target, bool add);\nvoid computeMultiSoftmaxCost(NVMatrix& labels, NVMatrix& probs, NVMatrix& maxProbs, NVMatrix& labelLogProbs_out,\n NVMatrix& correctProbs_out, NVMatrix& top5Probs_out, int setSize);\n#endif\t/* LAYER_KERNELS_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/lr.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef LR_CUH\n#define LR_CUH\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"util.cuh\"\n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"../../util/include/matrix.h\"\n\n/*\n * The maximum learning rate is _baseRate.\n * The minimum learning rate is _baseRate / _tgtFactor.\n *\n * These classes define annealing schedules that interpolate between these\n * two extrema.\n */\nclass ParameterSchedule {\nprotected:\n double _baseRate;\npublic:\n ParameterSchedule(double base);\n virtual double getValue(double progress);\n double getBaseValue() const;\n virtual ~ParameterSchedule();\n\n static ParameterSchedule& make(PyObject* schedDict);\n};\n\nclass LinearParameterSchedule : public ParameterSchedule {\nprotected:\n double _finalRate;\npublic:\n LinearParameterSchedule(double base, double tgtFactor);\n virtual double getValue(double progress);\n};\n\nclass ExpParameterSchedule : public ParameterSchedule {\nprotected:\n double _powBase;\npublic:\n ExpParameterSchedule(double baseRate, double tgtFactor);\n virtual double getValue(double progress);\n};\n\nclass DiscreteExpParameterSchedule : public ParameterSchedule {\nprotected:\n std::vector _rates;\npublic:\n DiscreteExpParameterSchedule(double baseRate, double tgtFactor, int numSteps);\n virtual double getValue(double progress);\n};\n\n\n#endif /* LR_CUH */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/memorysource.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n\nclass MemorySource;\n\nclass MemoryView {\nprotected:\n MemorySource* _src;\n std::string _name;\npublic:\n MemoryView(MemorySource& src, std::string& name);\n ~MemoryView();\n NVMatrix& getMemory(int numCases);\n NVMatrix& getMemory();\n MemorySource& getMemorySource();\n bool isParent();\n std::string& getName();\n MemoryView& clone(std::string& name);\n};\n\n// Remember: PassThroughLayer, and therefore MemorySource, exists on a particular GPU.\nclass MemorySource {\nprotected:\n// int _inputIdx;\n NVMatrix _memory;\n int _deviceID;\n int _size;\n std::map > _viewRanges;\n std::map _memoryViews; // input idx --> slice of _memory\n std::set _truncateRequests;\n Lock _lock;\npublic:\n MemorySource(int size, int deviceID);\n ~MemorySource();\n NVMatrix& getMemory(std::string& name, int numCases);\n NVMatrix& getMemory(std::string& name);\n MemoryView& addUser(std::string& name, std::pair range);\n MemoryView& addUser(std::string& name);\n std::pair getRange(std::string& name);\n int getSize();\n bool truncate(std::string& name);\n static MemoryView& make(int size, int deviceID, std::string& parentUser);\n};\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/messages.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef MESSAGES_CUH_\n#define MESSAGES_CUH_\n\n#include \n#include \"layer.cuh\"\n\nclass Layer;\n\nenum MESSAGES { FPROP_TERMINAL,\n BPROP_TERMINAL,\n BPROP_READY,\n FPROP_READY,\n SYNC,\n COPY_TO_CPU,\n COPY_TO_GPU,\n UPDATE_WEIGHTS,\n CONSTRAIN_WEIGHTS,\n RESET,\n RESET_PASS_IDX,\n COST_COMPUTED,\n BPROP_START,\n EXIT_CONVNET};\n\nclass Message {\nprotected:\n MESSAGES _messageType;\npublic:\n MESSAGES getType() {\n return _messageType;\n }\n virtual Message* clone() {\n return new Message(_messageType);\n }\n Message(MESSAGES messageType) : _messageType(messageType) {\n }\n virtual ~Message() {\n }\n};\n\nclass PropMessage : public Message {\nprotected:\n Layer *_toLayer;\n PASS_TYPE _passType;\n int _passIdx;\npublic:\n\n Layer& getToLayer() {\n return *_toLayer;\n }\n\n PASS_TYPE getPassType() {\n return _passType;\n }\n\n int getPassIdx() {\n return _passIdx;\n }\n\n virtual PropMessage* clone() {\n return new PropMessage(*_toLayer, _passType, _passIdx, _messageType);\n }\n\n PropMessage(Layer& toLayer, PASS_TYPE passType, int passIdx, MESSAGES msgType)\n : _toLayer(&toLayer), _passType(passType), _passIdx(passIdx), Message(msgType) {\n }\n};\n\nclass FpropMessage : public PropMessage {\npublic:\n FpropMessage(Layer& toLayer, PASS_TYPE passType, int passIdx)\n : PropMessage(toLayer, passType, passIdx, FPROP_READY) {\n }\n virtual FpropMessage* clone() {\n return new FpropMessage(*_toLayer, _passType, _passIdx);\n }\n};\n\nclass BpropMessage : public PropMessage {\npublic:\n BpropMessage(Layer& toLayer, PASS_TYPE passType, int passIdx)\n : PropMessage(toLayer, passType, passIdx, BPROP_READY) {\n }\n virtual BpropMessage* clone() {\n return new BpropMessage(*_toLayer, _passType, _passIdx);\n }\n};\n\nclass BpropStartMessage : public Message {\nprotected:\n PASS_TYPE _passType;\n int _passIdx;\npublic:\n PASS_TYPE getPassType() {\n return _passType;\n }\n\n int getPassIdx() {\n return _passIdx;\n }\n\n virtual BpropStartMessage* clone() {\n return new BpropStartMessage(_passType, _passIdx);\n }\n\n BpropStartMessage(PASS_TYPE passType, int passIdx)\n : _passType(passType), Message(BPROP_START), _passIdx(passIdx) {\n }\n};\n\n\n\n#endif /* MESSAGES_CUH_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/neuron.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef NEURONS_CUH\n#define\tNEURONS_CUH\n\n#include \n#include \n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \n\ntemplate \nclass AddGradientBinaryOperator {\n GradientOp _op;\npublic:\n AddGradientBinaryOperator(GradientOp op) : _op(op) {\n }\n __device__ inline float operator()(const float unitActGrad, const float unitAct, const float target) const {\n return _op(unitActGrad, unitAct) + target; \n }\n};\n\ntemplate \nclass AddGradientOperator {\n GradientOp _op;\npublic:\n AddGradientOperator(GradientOp op) : _op(op) {\n }\n __device__ inline float operator()(const float unitActGrad, const float target) const {\n return target + _op(unitActGrad); \n }\n};\n\n/* =======================\n * Neuron\n * -----------------------\n * \n * f(x) = x\n * =======================\n */\nclass Neuron {\nprotected:\n bool _activated;\n // Inputs and outputs potentially point to the same matrix, depending on the neuron\n NVMatrix* _inputs, *_outputs; \n virtual void _activate() {\n if (_inputs != _outputs) {\n _inputs->copy(*_outputs);\n }\n }\n virtual void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n if (&target != &actsGrad) {\n actsGrad.copy(target);\n }\n }\n virtual void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n if (&target != &actsGrad) {\n target.add(actsGrad);\n }\n }\npublic:\n Neuron() : _activated(false), _inputs(NULL), _outputs(NULL) {\n }\n virtual void activate(NVMatrix& inputs, NVMatrix& outputs) {\n _activated = true;\n _inputs = &inputs;\n _outputs = &outputs;\n _activate();\n }\n\n virtual void computeInputGrad(NVMatrix& actsGrad, NVMatrix& target, bool add) {\n assert(_activated);\n if (!add) {\n target.resize(actsGrad);\n _computeInputGrad(actsGrad, target);\n } else {\n _addInputGrad(actsGrad, target);\n }\n }\n \n static Neuron& makeNeuron(PyObject* neuronDict);\n};\n\n/* =======================\n * LogisticNeuron\n * -----------------------\n * \n * f(x) = 1 / (1 + e^-x)\n * =======================\n */\nclass LogisticNeuron : public Neuron {\nprotected:\n void _activate() {\n _inputs->apply(NVMatrixOps::Logistic(), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(LogisticGradientOperator(), *_outputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(LogisticGradientOperator()), *_outputs, target, target);\n }\npublic:\n class LogisticGradientOperator {\n public:\n __device__ inline float operator()(float unitActGrad, float unitAct) const {\n return unitActGrad * unitAct * (1.0f - unitAct); \n }\n };\n \n LogisticNeuron() : Neuron() {\n }\n};\n\n/* =======================\n * LogNeuron\n * -----------------------\n *\n * f(x) = log(eps + x)\n * =======================\n */\nclass LogNeuron : public Neuron {\nprotected:\n float _eps;\n void _activate() {\n _inputs->apply(LogOperator(_eps), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(LogGradientOperator(_eps), *_inputs, target);\n }\n\n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(LogGradientOperator(_eps)), *_inputs, target, target);\n }\npublic:\n class LogGradientOperator {\n protected:\n float _eps;\n public:\n __device__ inline float operator()(float unitActGrad, float unitInput) const {\n return __fdividef(unitActGrad, _eps + unitInput);\n }\n LogGradientOperator(float eps) : _eps(eps) {\n\n }\n };\n\n class LogOperator {\n protected:\n float _eps;\n public:\n __device__ inline float operator()(float x) const {\n return __logf(_eps + x);\n }\n LogOperator(float eps) : _eps(eps) {\n\n }\n };\n\n LogNeuron(float eps) : _eps(eps), Neuron() {\n }\n};\n\n/* =======================\n * ReluNeuron\n * -----------------------\n * \n * f(x) = max(0, x)\n * =======================\n */\nclass ReluNeuron : public Neuron {\nprotected:\n virtual void _activate() {\n _inputs->apply(ReluOperator(), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(ReluGradientOperator(), *_outputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(ReluGradientOperator()), *_outputs, target, target);\n }\npublic:\n class ReluOperator {\n public: \n __device__ inline float operator()(float x) const {\n return x < 0.0f ? 0.0f : x;\n }\n };\n\n class ReluGradientOperator {\n public:\n __device__ inline float operator()(float unitActGrad, float unitAct) const {\n return unitActGrad * (unitAct > 0.0f); \n }\n };\n \n ReluNeuron() : Neuron() {\n }\n};\n\n\n/* =======================\n * BoundedReluNeuron\n * -----------------------\n * \n * f(x) = min(a, max(0, x))\n * =======================\n */\nclass BoundedReluNeuron : public Neuron {\nprotected:\n float _a;\n \n void _activate() {\n _inputs->apply(BoundedReluOperator(_a), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(BoundedReluGradientOperator(_a), *_outputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(BoundedReluGradientOperator(_a)), *_outputs, target, target);\n }\npublic:\n class BoundedReluOperator {\n private:\n float _a;\n public:\n BoundedReluOperator(float a) : _a(a) {\n }\n __device__ inline float operator()(float x) const {\n return x < 0.0f ? 0.0f : x > _a ? _a : x;\n }\n };\n\n class BoundedReluGradientOperator {\n private:\n float _a;\n public:\n BoundedReluGradientOperator(float a) : _a(a) {\n }\n __device__ inline float operator()(float unitActGrad, float unitAct) const {\n return unitActGrad * (unitAct > 0.0f) * (unitAct < _a); \n }\n };\n \n BoundedReluNeuron(float a) : Neuron(), _a(a) {\n }\n};\n\n/* =======================\n * AbsNeuron\n * -----------------------\n * \n * f(x) = abs(x)\n * =======================\n */\nclass AbsNeuron : public Neuron {\nprotected:\n void _activate() {\n assert(_inputs != _outputs);\n _inputs->apply(NVMatrixOps::Abs(), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(AbsGradientOperator(), *_inputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(AbsGradientOperator()), *_inputs, target, target);\n }\npublic:\n class AbsGradientOperator {\n public:\n __device__ inline float operator()(float unitActGrad, float unitInput) const {\n return unitActGrad * (unitInput > 0.0f ? 1.0f : -1.0f); \n }\n };\n \n AbsNeuron() : Neuron() {\n }\n};\n\n/* =======================\n * TanhNeuron\n * -----------------------\n * \n * f(x) = a*tanh(b*x)\n * =======================\n */\nclass TanhNeuron : public Neuron {\nprotected:\n float _a, _b;\n\n void _activate() {\n _inputs->apply(TanhOperator(_a, _b), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(TanhGradientOperator(_a, _b), *_outputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(TanhGradientOperator(_a, _b)), *_outputs, target, target);\n }\npublic:\n class TanhOperator {\n private:\n float _a, _n2b;\n public:\n TanhOperator(float a, float b) : _a(a), _n2b(-2*b) {\n }\n virtual __device__ inline float operator()(float x) const {\n return _a * (__fdividef(2.0f, 1.0f + __expf(x * _n2b)) - 1.0f);\n }\n };\n\n class TanhGradientOperator {\n private:\n float _b, _a;\n public:\n TanhGradientOperator(float a, float b) : _b(b), _a(a) {\n }\n __device__ inline float operator()(float unitActGrad, float unitAct) const {\n// const float t = (1.0f - __fdividef(unitAct, _a)) / 2.0f;\n// return unitActGrad * _n4ab * (t * (t - 1.0f));\n return unitActGrad * _b * (_a - __fdividef(unitAct * unitAct, _a));\n }\n };\n \n TanhNeuron(float a, float b) : Neuron(), _a(a), _b(b) {\n }\n};\n\n/* =======================\n * DoubleReluNeuron\n * -----------------------\n * \n * f(x) = x - a*tanh(x/a)\n * =======================\n */\nclass DoubleReluNeuron : public Neuron {\nprotected:\n float _a;\n\n void _activate() {\n assert(_inputs != _outputs);\n _inputs->apply(DoubleReluOperator(_a), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(DoubleReluGradientOperator(_a), *_inputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(DoubleReluGradientOperator(_a)), *_inputs, target, target);\n }\npublic:\n class DoubleReluOperator {\n private:\n float _a, _n2a;\n public:\n DoubleReluOperator(float a) : _a(a), _n2a(-2.0f / a) {\n }\n virtual __device__ inline float operator()(float x) const {\n return x - _a * (__fdividef(2.0f, 1.0f + __expf(_n2a * x)) - 1.0f);\n }\n };\n\n class DoubleReluGradientOperator {\n private:\n float _n2a;\n public:\n DoubleReluGradientOperator(float a) : _n2a(-2.0f / a) {\n }\n __device__ inline float operator()(float unitActGrad, float unitInput) const {\n const float tanh = __fdividef(2.0f, 1.0f + __expf(_n2a * unitInput)) - 1.0f;\n return unitActGrad * (tanh*tanh);\n }\n };\n \n DoubleReluNeuron(float a) : Neuron(), _a(a) {\n }\n};\n\n/* =======================\n * SoftReluNeuron\n * -----------------------\n * \n * f(x) = log(1 + e^x)\n * =======================\n */\nclass SoftReluNeuron : public Neuron {\nprotected:\n void _activate() {\n// assert(_inputs != _outputs);\n _inputs->apply(SoftReluOperator(), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(SoftReluGradientOperator(), *_outputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(SoftReluGradientOperator()), *_outputs, target, target);\n }\npublic:\n class SoftReluOperator {\n public: \n __device__ inline float operator()(float x) const {\n // This piece-wise implementation has better numerical stability than\n // simply computing log(1 + e^x).\n return x > 4.0f ? x : __logf(1.0f + __expf(x));\n }\n };\n\n class SoftReluGradientOperator {\n public:\n __device__ inline float operator()(float unitActGrad, float unitOutput) const {\n if (unitOutput > 4.0f) {\n return unitActGrad;\n }\n const float f = __expf(-unitOutput);\n return unitActGrad * (1.0f - f);\n }\n };\n \n SoftReluNeuron() : Neuron() {\n }\n};\n\n/* =======================\n * SquareNeuron\n * -----------------------\n * \n * f(x) = x^2\n * =======================\n */\nclass SquareNeuron : public Neuron {\nprotected:\n void _activate() {\n assert(_inputs != _outputs);\n _inputs->apply(NVMatrixOps::Square(), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(SquareGradientOperator(), *_inputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(SquareGradientOperator()), *_inputs, target, target);\n }\npublic:\n class SquareGradientOperator {\n public:\n __device__ inline float operator()(float unitActGrad, float unitInput) const {\n return unitActGrad * 2.0f * unitInput; \n }\n };\n \n SquareNeuron() : Neuron() {\n }\n};\n\n/* =======================\n * SqrtNeuron\n * -----------------------\n * \n * f(x) = sqrt(x)\n * =======================\n */\nclass SqrtNeuron : public Neuron {\nprotected:\n void _activate() {\n _inputs->apply(NVMatrixOps::Sqrt(), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(SqrtGradientOperator(), *_outputs, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyTernary(AddGradientBinaryOperator(SqrtGradientOperator()), *_outputs, target, target);\n }\npublic:\n class SqrtGradientOperator {\n public:\n __device__ inline float operator()(float unitActGrad, float unitAct) const {\n return __fdividef(unitActGrad, 2.0f * unitAct); \n }\n };\n \n SqrtNeuron() : Neuron() {\n }\n};\n\n/* =======================\n * LinearNeuron\n * -----------------------\n * \n * f(x) = a*x + b\n * =======================\n */\nclass LinearNeuron : public Neuron {\nprotected:\n float _a, _b;\n void _activate() {\n _inputs->apply(NVMatrixOps::Linear(_a, _b), *_outputs);\n }\n\n void _computeInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.scale(_a, target);\n }\n \n void _addInputGrad(NVMatrix& actsGrad, NVMatrix& target) {\n actsGrad.applyBinary(AddGradientOperator(NVMatrixOps::MultByScalar(_a)), target, target);\n }\npublic:\n LinearNeuron(float a, float b) : Neuron(), _a(a), _b(b) {\n }\n};\n#endif\t/* NEURONS_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/pipedispenser.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef PIPEDISPENSER_CUH_\n#define PIPEDISPENSER_CUH_\n\n#include \n#include \n#include \n#include \n#include \"../../util/include/thread.h\"\n#include \"util.cuh\"\n\n/*\n * PipeDispenser interface\n */\nclass PipeDispenser {\nprotected:\n int _numPipes;\n seti _pipes;\n pthread_mutex_t *_mutex;\n\n void lock() {\n pthread_mutex_lock(_mutex);\n }\n\n void unlock() {\n pthread_mutex_unlock(_mutex);\n }\n\n virtual void init() {\n _mutex = (pthread_mutex_t*)(malloc(sizeof (pthread_mutex_t)));\n pthread_mutex_init(_mutex, NULL);\n }\npublic:\n PipeDispenser(const seti& pipes) {\n _pipes.insert(pipes.begin(), pipes.end());\n init();\n }\n\n PipeDispenser(int numPipes) {\n for (int i = 0; i < numPipes; ++i) {\n _pipes.insert(i);\n }\n init();\n }\n\n virtual ~PipeDispenser() {\n pthread_mutex_destroy(_mutex);\n free(_mutex);\n }\n\n virtual int getPipe(const seti& interested) = 0;\n\n int getPipe(int interested) {\n seti tmp;\n tmp.insert(interested);\n return getPipe(tmp);\n }\n\n virtual void freePipe(int pipe) = 0;\n};\n\n/*\n * This one blocks until there is a free pipe to return.\n */\nclass PipeDispenserBlocking : public PipeDispenser {\nprotected:\n pthread_cond_t *_cv;\n\n void wait() {\n pthread_cond_wait(_cv, _mutex);\n }\n\n void broadcast() {\n pthread_cond_broadcast(_cv);\n }\n\n int getAvailablePipes(const seti& interested, intv& available) {\n available.clear();\n std::set_intersection(_pipes.begin(), _pipes.end(), interested.begin(), interested.end(), std::back_inserter(available));\n return available.size();\n }\n\n virtual void init() {\n PipeDispenser::init();\n _cv = (pthread_cond_t*)(malloc(sizeof (pthread_cond_t)));\n pthread_cond_init(_cv, NULL);\n }\npublic:\n PipeDispenserBlocking(const seti& pipes) : PipeDispenser(pipes) {\n init();\n }\n\n PipeDispenserBlocking(int numPipes) : PipeDispenser(numPipes) {\n init();\n }\n\n ~PipeDispenserBlocking() {\n pthread_cond_destroy(_cv);\n free(_cv);\n }\n\n int getPipe(const seti& interested) {\n lock();\n intv avail;\n while (getAvailablePipes(interested, avail) == 0) {\n wait();\n }\n int pipe = avail[0];\n _pipes.erase(pipe);\n unlock();\n return pipe;\n }\n\n void freePipe(int pipe) {\n lock();\n _pipes.insert(pipe);\n broadcast();\n unlock();\n }\n};\n\n/*\n * This one returns the least-occupied pipe.\n */\nclass PipeDispenserNonBlocking : public PipeDispenser {\nprotected:\n std::map _pipeUsers;\n\npublic:\n PipeDispenserNonBlocking(const seti& pipes) : PipeDispenser(pipes) {\n for (seti::iterator it = pipes.begin(); it != pipes.end(); ++it) {\n _pipeUsers[*it] = 0;\n }\n }\n\n int getPipe(const seti& interested) {\n lock();\n int pipe = -1, users = 1 << 30;\n for (seti::iterator it = _pipes.begin(); it != _pipes.end(); ++it) {\n if (interested.count(*it) > 0 && _pipeUsers[*it] < users) {\n pipe = *it;\n users = _pipeUsers[*it];\n }\n }\n if (pipe >= 0) {\n _pipeUsers[pipe]++;\n }\n unlock();\n return pipe;\n }\n\n void freePipe(int pipe) {\n lock();\n _pipeUsers[pipe]--;\n unlock();\n }\n};\n\n\n#endif /* PIPEDISPENSER_CUH_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/pyconvnet.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef PYCONVNET3_CUH\n#define\tPYCONVNET3_CUH\n\n#define _QUOTEME(x) #x\n#define QUOTEME(x) _QUOTEME(x)\n\nextern \"C\" void init_ConvNet();\n\nPyObject* initModel(PyObject *self, PyObject *args);\nPyObject* startBatch(PyObject *self, PyObject *args);\nPyObject* finishBatch(PyObject *self, PyObject *args);\nPyObject* checkGradients(PyObject *self, PyObject *args);\nPyObject* syncWithHost(PyObject *self, PyObject *args);\nPyObject* startMultiviewTest(PyObject *self, PyObject *args);\nPyObject* startFeatureWriter(PyObject *self, PyObject *args);\nPyObject* startDataGrad(PyObject *self, PyObject *args);\nPyObject* decodeJpeg(PyObject *self, PyObject *args);\n\n#endif\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/reducepipeline.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef REDUCEPIPELINE_CUH_H_\n#define REDUCEPIPELINE_CUH_H_\n\n#include \"../../util/include/thread.h\"\n#include \"../../util/include/queue.h\"\n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"util.cuh\"\n\n#define REDUCE_MIN_CHUNK_SIZE (1<<18) // 256k\n#define REDUCE_MAX_CHUNKS 16\n#define REDUCE_MIN_CHUNKS 2\n\nenum REDUCE_MESSAGE_TYPE {\n REDUCE_CHUNK,\n REDUCE_START,\n EXIT\n};\n\nclass ReducePeer;\nclass ReducerSource;\nclass IReduceSegment;\nclass IEightGPUReducer;\n\nclass ReduceMessage {\nprotected:\n REDUCE_MESSAGE_TYPE _msgType;\n float _scaleIntermediates, _scaleTarget;\n std::map* _mats;\npublic:\n ReduceMessage(REDUCE_MESSAGE_TYPE msgType, float scaleIntermediates, float scaleTarget, std::map& mats)\n : _msgType(msgType), _scaleIntermediates(scaleIntermediates), _scaleTarget(scaleTarget), _mats(&mats) {\n }\n ReduceMessage(REDUCE_MESSAGE_TYPE msgType)\n : _msgType(msgType), _scaleIntermediates(0), _scaleTarget(0), _mats(NULL) {\n }\n inline REDUCE_MESSAGE_TYPE getType() const {\n return _msgType;\n }\n inline float getScaleIntermediates() const {\n return _scaleIntermediates;\n }\n inline float getScaleTarget() const {\n return _scaleTarget;\n }\n inline NVMatrix& getMatrix(int deviceID) const {\n return *_mats->at(deviceID);\n }\n inline std::map& getMatrices() const {\n return *_mats;\n }\n};\n\nclass ReduceChunkMessage : public ReduceMessage {\nprotected:\n int _chunkIdx;\n int _chunkSize;\n int _numChunks;\n\n IReduceSegment* _src;\npublic:\n ReduceChunkMessage(IReduceSegment& src, int chunkIdx, int chunkSize, int numChunks, float scaleIntermediates, float scaleTarget, std::map& mats)\n : _src(&src), _chunkIdx(chunkIdx), _chunkSize(chunkSize), _numChunks(numChunks),\n ReduceMessage(REDUCE_CHUNK, scaleIntermediates, scaleTarget, mats) {\n }\n\n inline int getChunkIdx() const {\n return _chunkIdx;\n }\n\n inline int getChunkSize() const {\n return _chunkSize;\n }\n\n inline int getNumChunks() const {\n return _numChunks;\n }\n\n inline IReduceSegment& getSource() const {\n return *_src;\n }\n};\n\nclass ReduceStartMessage : public ReduceMessage {\npublic:\n ReduceStartMessage(float scaleIntermediates, float scaleTarget, std::map& mats)\n : ReduceMessage(REDUCE_START, scaleIntermediates, scaleTarget, mats) {\n }\n};\n\nclass IReduceSegment : public Thread {\nprotected:\n int _deviceID;\n std::vector _prev;\n ReducePeer* _next;\n Queue _queue;\n Queue* _finishQueue;\n\n NVMatrix& getChunk(const NVMatrix& mat, int chunkSize, int chunkIdx);\n void* run();\n virtual bool processMessage(ReduceMessage& msg) = 0;\n\npublic:\n IReduceSegment(IEightGPUReducer& parent, int deviceID, Queue* finishQueue);\n virtual ~IReduceSegment();\n inline virtual NVMatrix& getMatrix(ReduceMessage& msg);\n Queue& getQueue();\n int getDeviceID() const;\n void addPrev(IReduceSegment& c);\n void addNext(ReducePeer& c);\n bool isTerminal() const;\n};\n\nclass ReducerSource : public IReduceSegment {\nprotected:\n bool processMessage(ReduceMessage& msg);\npublic:\n ReducerSource(IEightGPUReducer& parent, int deviceID);\n};\n\nclass ReducePeer : public IReduceSegment {\nprotected:\n std::map _streams; // device id -> stream\n std::map _numInputsReceived; // chunk idx -> num inputs\n int _numInputsFinished;\n HostNVMatrix _mat;\n bool _add;\n bool processMessage(ReduceMessage& msg);\n inline cudaStream_t getStream(int deviceID);\n inline NVMatrix& getMatrix(ReduceMessage& msg);\n void hostAdd(const float* src, float* tgt, const int n, const float scaleTgt);\npublic:\n ReducePeer(IEightGPUReducer& parent, int deviceID, Queue* finishQueue);\n ReducePeer(IEightGPUReducer& parent);\n ~ReducePeer();\n};\n\nclass IEightGPUReducer {\nprotected:\n std::vector _sources;\n std::vector _peers;\n Queue _finishQueue;\n int _tgtDeviceID;\n virtual void makeConnections(std::vector& same, std::vector&other) = 0;\npublic:\n IEightGPUReducer(int tgtDeviceID);\n virtual ~IEightGPUReducer();\n IEightGPUReducer& construct();\n void reduce(std::map& mats, float scaleIntermediates, float scaleTarget);\n void reduce(std::map& mats, float scaleIntermediates);\n void reduce(std::map& mats);\n int getTgtDeviceID() const;\n};\n\nclass EightGPUReducer1 : public IEightGPUReducer {\nprotected:\n void makeConnections(std::vector& same, std::vector&other);\npublic:\n EightGPUReducer1(int tgtDeviceID);\n};\n\nclass EightGPUReducer2 : public IEightGPUReducer {\nprotected:\n void makeConnections(std::vector& same, std::vector&other);\npublic:\n EightGPUReducer2(int tgtDeviceID);\n};\n\n#endif /* REDUCEPIPELINE_CUH_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/streambroadcast.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef STREAMBROADCAST_CUH_\n#define STREAMBROADCAST_CUH_\n\n#include \n#include \"../../util/include/queue.h\"\n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"util.cuh\"\n\nclass Layer;\n\n//#define NUM_STREAM_COPY_PARTS 4\n// This is in 4-byte words, not bytes\n#define SB_MIN_CHUNK_SIZE (1<<17)\n#define SB_MAX_CHUNKS 16\n\nclass StreamBroadcast {\nprotected:\n std::map _streams;\n std::set _ownedStreams;\n HostNVMatrix _hostMem;\n void toHostMem(NVMatrix& src, NVMatrix& hostmem, int srcDevice);\n void toTarget(NVMatrix& hostmem, NVMatrix& tgt, int tgtDevice, float scaleTarget, float scaleOutput);\n void init(std::map& streams);\n void init(std::map& mats);\npublic:\n StreamBroadcast(std::map& streams);\n StreamBroadcast();\n virtual ~StreamBroadcast();\n\n void transfer(std::map& mats, HostNVMatrix& hostmem, int srcDevice, float scaleTarget, float scaleOutput);\n void transfer(std::map& mats, int srcDevice, float scaleTarget, float scaleOutput);\n void transfer(std::map& mats, int srcDevice);\n void sync(int deviceID);\n cudaStream_t getStream(int deviceID);\n};\n\n#endif /* STREAMBROADCAST_CUH_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/timer.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef TIMER_CC_H_\n#define TIMER_CC_H_\n\n#include \n\nclass Timer {\nprotected:\n StopWatchInterface* _timer;\n bool _started;\n\npublic:\n Timer() : _started(false) {\n sdkCreateTimer(&_timer);\n }\n\n ~Timer() {\n sdkDeleteTimer(&_timer);\n }\n inline void start () {\n _started = true;\n sdkResetTimer(&_timer);\n sdkStartTimer(&_timer);\n }\n\n inline double stop() {\n sdkStopTimer(&_timer);\n _started = false;\n return sdkGetTimerValue(&_timer);\n }\n\n inline bool isStarted() const {\n return _started;\n }\n};\n\n#endif /* TIMER_CC_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/util.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef UTIL_H\n#define\tUTIL_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"../../util/include/matrix.h\"\n\n\n#define PASS_TYPE uint\n#define PASS_TRAIN 0x1\n#define PASS_TEST 0x2\n#define PASS_GC 0x4\n#define PASS_MULTIVIEW_TEST (PASS_TEST | 0x8)\n#define PASS_MULTIVIEW_TEST_START (PASS_MULTIVIEW_TEST | 0x10)\n#define PASS_MULTIVIEW_TEST_END (PASS_MULTIVIEW_TEST | 0x20)\n#define PASS_FEATURE_GEN 0x40\n\n#define HAS_FLAG(f, x) (((x) & (f)) == (f))\n#define IS_MULTIVIEW_TEST(x) HAS_FLAG(PASS_MULTIVIEW_TEST, x)\n#define IS_MULTIVIEW_TEST_START(x) HAS_FLAG(PASS_MULTIVIEW_TEST_START, x)\n#define IS_MULTIVIEW_TEST_END(x) HAS_FLAG(PASS_MULTIVIEW_TEST_END, x)\n#define IS_TEST(x) HAS_FLAG(PASS_TEST, x)\n#define IS_TRAIN(x) HAS_FLAG(PASS_TRAIN, x)\n\n// For gradient checking\n#define GC_SUPPRESS_PASSES false\n#define GC_REL_ERR_THRESH 0.02\n\n#ifdef DO_PRINT\n#define PRINT(x, args...) printf(x, ## args);\n#else\n#define PRINT(x, args...) ;\n#endif\n\n/*\n * Generates a random floating point number in the range 0-1.\n */\n#define randf ((float)rand() / RAND_MAX)\n\n//typedef std::vector MatrixV;\n//typedef std::vector NVMatrixV;\ntypedef std::map*> CostMap;\ntypedef std::map CostCoeffMap;\ntypedef std::vector doublev;\ntypedef std::vector floatv;\ntypedef std::vector intv;\ntypedef std::vector stringv;\ntypedef std::set seti;\ntypedef std::vector PyObjectV;\n\nstringv* getStringV(PyObject* pyList);\nfloatv* getFloatV(PyObject* pyList);\nintv* getIntV(PyObject* pyList);\nMatrixV* getMatrixV(PyObject* pyList);\nMatrixV* getMatrixV(PyObject* pyList, int len);\nint* getIntA(PyObject* pyList);\n\nint pyDictGetInt(PyObject* dict, const char* key);\nintv* pyDictGetIntV(PyObject* dict, const char* key);\nstd::string pyDictGetString(PyObject* dict, const char* key);\nfloat pyDictGetFloat(PyObject* dict, const char* key);\nfloatv* pyDictGetFloatV(PyObject* dict, const char* key);\nMatrix* pyDictGetMatrix(PyObject* dict, const char* key);\nMatrixV* pyDictGetMatrixV(PyObject* dict, const char* key);\nint* pyDictGetIntA(PyObject* dict, const char* key);\nstringv* pyDictGetStringV(PyObject* dict, const char* key);\nbool pyDictHasKey(PyObject* dict, const char* key);\nPyObjectV* pyDictGetValues(PyObject* dict);\n\ntemplate std::string tostr(T n);\ntemplate void shuffleVector(std::vector& v, int start, int end);\ntemplate void deleteElements(std::vector& v);\ntemplate void deleteElements(std::vector& v, bool deleteContainer);\n\ntemplate\nint indexOf(std::vector& v, T e) {\n int i = 0;\n// typename vector::iterator it2 = v.begin();\n for (typename std::vector::const_iterator it = v.begin(); it != v.end(); ++it) {\n if (*it == e) {\n return i;\n }\n ++i;\n }\n return -1;\n}\n\nstd::vector& getDeviceCPUs(int deviceID);\n\ntemplate std::set getKeys(std::map& m) {\n std::set s;\n for (typename std::map::const_iterator it = m.begin(); it != m.end(); ++it) {\n s.insert(it->first);\n }\n return s;\n}\n\nstruct LayerIDComparator {\n bool operator()(PyObject* i, PyObject* j) {\n return pyDictGetInt(i, \"id\") < pyDictGetInt(j, \"id\");\n }\n};\n\n#endif\t/* UTIL_H */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/weights.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef WEIGHTS_CUH\n#define\tWEIGHTS_CUH\n\n#include \n#include \n#include \n#include \n#include \n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"../../util/include/matrix.h\"\n#include \"util.cuh\"\n#include \"lr.cuh\"\n#include \"layer.cuh\"\n#include \"copypipeline.cuh\"\n#include \"reducepipeline.cuh\"\n#include \"streambroadcast.cuh\"\n\nclass Layer;\nclass Weights;\nclass StreamBroadcast;\n\nclass IWeightReducer {\nprotected:\n int _tgtReplicaID;\n std::map _replicas;\n\n int getDeviceID();\npublic:\n IWeightReducer(std::map& replicas, int srcReplicaID);\n virtual ~IWeightReducer();\n static IWeightReducer& make(std::map& replicas, int srcReplicaID);\n virtual void reduce(std::map gradShards, float gradScale, bool toInc) = 0;\n};\n\nclass SequentialWeightReducer : public IWeightReducer {\nprotected:\n StreamBroadcast* _sb;\npublic:\n SequentialWeightReducer(std::map& replicas, int srcReplicaID);\n ~SequentialWeightReducer();\n void reduce(std::map gradShards, float gradScale, bool toInc);\n};\n\nclass ParallelWeightReducer : public IWeightReducer {\nprotected:\n IEightGPUReducer* _reducer;\npublic:\n ParallelWeightReducer(std::map& replicas, int srcReplicaID);\n ~ParallelWeightReducer();\n void reduce(std::map gradShards, float gradScale, bool toInc);\n};\n\nclass Weights {\nprotected:\n Matrix* _hWeights, *_hWeightsInc;\n NVMatrix* _weights, *_weightsInc, *_weightsGrad;\n \n ParameterSchedule* _lrs;\n\n float _wc, _mom, _wball;\n bool _onGPU, _useGrad, _cleanup;\n int _numUpdates;\n\n // Note: every layer is its own sibling too\n std::map _replicas;\n \n // Non-NULL if these weights are really shared from some other layer\n Weights* _srcWeights;\n Layer* _parent;\n int _shardSize;\n IWeightReducer* _reducer;\n ISafeBroadcastNetwork* _broadcaster;\n\n void aggregateReplicaGradients(float progress);\n\n // TODO: assert that these retrun contiguous views\n template T& getShard(T& mat, int replicaID);\n template T& getShard(T& mat);\n void init(Matrix& hWeights, Matrix& hWeightsInc, ParameterSchedule& lrs, Layer& parent, float wc, float wball, float mom, bool useGrad, bool cleanup);\n\npublic:\n NVMatrix& operator*() const;\n \n Weights(Weights& srcWeights, ParameterSchedule& lrs, Layer& parent);\n Weights(Matrix& hWeights, Matrix& hWeightsInc, ParameterSchedule& lrs, Layer& parent,\n float wc, float wball, float mom, bool useGrad);\n \n virtual ~Weights();\n\n virtual NVMatrix& getW() const;\n virtual NVMatrix& getInc() const;\n virtual NVMatrix& getGrad() const;\n virtual Matrix& getCPUW() const;\n virtual Matrix& getCPUWInc() const;\n virtual ParameterSchedule& getLearningRateSchedule() const;\n virtual int getNumRows() const;\n virtual int getNumCols() const;\n virtual void copyToCPU();\n \n // This function is assumed to be called in the order in which the layers\n // were defined\n virtual void copyToGPU();\n \n virtual void update(float progress);\n virtual void addReplica(Weights& sibling);\n int incNumUpdates();\n \n // Returns the number of times a gradient has been computed for this\n // weight matrix during the current pass (interval between two calls of update())\n // through the net. This number will only be greater than 1 if this weight matrix\n // is *shared* by multiple layers in the net.\n int getNumUpdates() const;\n float getEps(float progress) const;\n float getMom() const;\n float getWC() const;\n float getWBall() const;\n bool isUseGrad() const;\n bool isOwner() const;\n int getReplicaID();\n int getDeviceID();\n Layer& getParent();\n std::map& getReplicas();\n ISafeBroadcastNetwork& getBroadcaster();\n IWeightReducer& getReducer();\n};\n\nclass WeightList {\nprivate:\n std::vector _weightList;\npublic:\n Weights& operator[](const int idx) const;\n ~WeightList();\n WeightList();\n Weights& at(const int i) const;\n void addWeights(Weights& w);\n void addReplica(WeightList& sibling);\n void update(float progress);\n void copyToCPU();\n void copyToGPU();\n int getSize() const;\n};\n\n#endif\t/* WEIGHTS_CUH */\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/include/worker.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef WORKER_CUH\n#define WORKER_CUH\n\n#include \"convnet.cuh\"\n#include \"cost.cuh\"\n#include \"data.cuh\"\n\nclass ConvNet;\nclass Cost;\n\nclass WorkResult {\npublic:\n enum RESULTS {BATCH_DONE, SYNC_DONE};\nprotected:\n WorkResult::RESULTS _resultType;\n Cost* _results;\npublic:\n WorkResult(WorkResult::RESULTS resultType, Cost& results);\n WorkResult(WorkResult::RESULTS resultType);\n virtual ~WorkResult();\n Cost& getResults() const;\n WorkResult::RESULTS getResultType() const;\n};\n\nclass Worker {\nprotected:\n ConvNet* _convNet;\npublic:\n Worker(ConvNet& convNet);\n virtual ~Worker();\n virtual bool run() = 0;\n};\n\nclass DataWorker : public Worker {\nprotected:\n CPUData* _data;\n DataProvider* _dp;\npublic:\n DataWorker(ConvNet& convNet, CPUData& data);\n virtual ~DataWorker();\n bool run();\n virtual void _run() = 0;\n};\n\nclass TrainingWorker : public DataWorker {\nprotected:\n bool _test;\n double _progress;\npublic:\n TrainingWorker(ConvNet& convNet, CPUData& data, double progress, bool test);\n void _run();\n};\n\nclass SyncWorker : public Worker {\npublic:\n SyncWorker(ConvNet& convNet);\n bool run();\n};\n\nclass ExitWorker : public Worker {\npublic:\n ExitWorker(ConvNet& convNet);\n bool run();\n};\n\nclass GradCheckWorker : public DataWorker {\npublic:\n GradCheckWorker(ConvNet& convNet, CPUData& data);\n void _run();\n};\n\nclass MultiviewTestWorker : public DataWorker {\nprotected:\n int _numViews;\n Matrix* _cpuProbs;\n std::string _logregName;\n CPUData& getMinibatch(int v, int i);\npublic:\n MultiviewTestWorker(ConvNet& convNet, CPUData& data, int numViews, Matrix& cpuProbs, const char* softmaxName);\n MultiviewTestWorker(ConvNet& convNet, CPUData& data, int numViews);\n ~MultiviewTestWorker();\n void _run();\n};\n\nclass FeatureWorker : public DataWorker {\nprotected:\n MatrixV *_ftrs;\n stringv *_layerNames;\n bool _deleteFeatures;\npublic:\n FeatureWorker(ConvNet& convNet, CPUData& data, MatrixV& ftrs, stringv& layerNames, bool deleteFeatures=true);\n ~FeatureWorker();\n void _run();\n};\n\nclass DataGradWorker : public DataWorker {\nprotected:\n Matrix* _dataGrads;\n int _dataLayerIdx, _softmaxLayerIdx;\npublic:\n DataGradWorker(ConvNet& convNet, CPUData& data, Matrix& dataGrads, int dataLayerIdx, int softmaxLayerIdx);\n ~DataGradWorker();\n void _run();\n};\n\n#endif/* WORKER_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/actbroadcaster.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n#include \"../include/actbroadcaster.cuh\"\n\nusing namespace std;\n\n/*\n * =====================\n * BroadcastMessage\n * =====================\n */\nBroadcastMessage::BroadcastMessage(map mats, int srcDevice, int userIdx, Queue& finishQueue)\n : _type(BROADCAST), _mats(mats), _srcDevice(srcDevice), _userIdx(userIdx), _finishQueue(&finishQueue) {\n}\n\nBroadcastMessage::BroadcastMessage(MESSAGE_TYPE type)\n : _type(type), _finishQueue(NULL) {\n}\n\nint BroadcastMessage::getSrcDevice() {\n return _srcDevice;\n}\n\nmap& BroadcastMessage::getMatrices() {\n return _mats;\n}\n\nint BroadcastMessage::getUserIdx() {\n return _userIdx;\n}\n\nQueue& BroadcastMessage::getFinishQueue() {\n return *_finishQueue;\n}\n\nBroadcastMessage::MESSAGE_TYPE BroadcastMessage::getMessageType() {\n return _type;\n}\n\n/*\n * =====================\n * ExitBroadcastMessage\n * =====================\n */\nExitBroadcastMessage::ExitBroadcastMessage() : BroadcastMessage(BroadcastMessage::EXIT) {\n}\n\n/*\n * =====================\n * ActBroadcaster\n * =====================\n */\nActBroadcaster::ActBroadcaster(int numUsers, intv& cpus) : Thread(true, cpus), _numUsers(numUsers) {\n}\n\nActBroadcaster::~ActBroadcaster() {\n for (map::const_iterator it = _broadcasters.begin(); it != _broadcasters.end(); ++it) {\n delete it->second;\n }\n}\n\nQueue& ActBroadcaster::getMessageQueue() {\n return _messageQueue;\n}\n\nvoid* ActBroadcaster::run() {\n int nextUserIdx = 0;\n bool exit = false;\n while (!exit) {\n BroadcastMessage& msg = *_messageQueue.dequeue();\n if (msg.getMessageType() == BroadcastMessage::EXIT) {\n exit = true;\n delete &msg;\n } else {\n if (msg.getUserIdx() == nextUserIdx) {\n if (_broadcasters.count(msg.getSrcDevice()) == 0) {\n _broadcasters[msg.getSrcDevice()] = &IBroadcastNetwork::make(getKeys(msg.getMatrices()), msg.getSrcDevice());\n }\n _broadcasters[msg.getSrcDevice()]->broadcast(msg.getMatrices());\n msg.getFinishQueue().enqueue(0);\n delete &msg;\n nextUserIdx = (nextUserIdx + 1) % _numUsers;\n } else {\n _messageQueue.enqueue(&msg);\n }\n }\n }\n return NULL;\n}\n\nvoid ActBroadcaster::stop() {\n getMessageQueue().enqueue(new ExitBroadcastMessage());\n join();\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/convnet.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"../../nvmatrix/include/nvmatrix.cuh\"\n#include \"../../nvmatrix/include/nvmatrix_operators.cuh\"\n#include \"../../util/include/matrix.h\"\n#include \"../include/convnet.cuh\"\n#include \"../include/util.cuh\"\n\nusing namespace std;\n\n/* \n * =======================\n * ConvNet\n * =======================\n */\nConvNet::ConvNet(PyObject* layerParams, intv& deviceIDs,\n int minibatchSize, bool conserveMem) : Thread(true) {\n _deviceIDs = deviceIDs;\n _data = NULL;\n _bufferData = NULL;\n _bufferMinibatchIdx = -1;\n _bufferPassIdx = -1;\n _trainingProgress = 0;\n _totalPassesDone = 0;\n _conserveMem = conserveMem;\n _sync = new ThreadSynchronizer(deviceIDs.size() + 1);\n PyObjectV* layerList = pyDictGetValues(layerParams);\n std::sort(layerList->begin(), layerList->end(), LayerIDComparator());\n\n \n _dataCopyPD = new PipeDispenserBlocking(DIVUP(_deviceIDs.size(),2)); // hard-coded for now\n\n initDataLayers(layerList);\n initGPUThreads(layerList);\n connectReplicas(); // Connect replicas to one another\n connectChildren(layerParams); // Connect forward/backward links in graph\n _numFwdTerminal = 0;\n // Execute post-initialization stuff\n for (NameReplicaLayerMap::iterator it = _layerMap.begin(); it != _layerMap.end(); ++it) {\n for (int r = 0; r < it->second.size(); r++) {\n _numFwdTerminal += it->second[r]->getNext().size() == 0;\n if (it->second[r]->getNext().size() == 0) {\n printf(\"Fwd terminal: %s\\n\", it->second[r]->getName().c_str());\n }\n it->second[r]->postInit();\n }\n }\n\n // Find and count the terminal nodes in the backward pass\n for (int p = 0; p < getNumPasses(); p++) {\n set visited;\n _numBwdTerminal[p] = 0;\n for (int t = 0; t < _convNetThreads.size(); t++) {\n vector& cl = _convNetThreads[t]->getCostLayers();\n for (int c = 0; c < cl.size(); c++) {\n findBwdTerminal(*cl[c], visited, _numBwdTerminal[p], p);\n }\n }\n }\n\n _dp = new DataProvider(minibatchSize);\n// Py_DECREF(layerList);\n delete layerList;\n}\n\nConvNet::~ConvNet() {\n for (vector::const_iterator it = _convNetThreads.begin(); it != _convNetThreads.end(); ++it) {\n (*it)->getMessageQueue().enqueue(new Message(EXIT_CONVNET));\n (*it)->join();\n delete *it;\n }\n for (DataLayerVector::const_iterator it = _dataLayers.begin(); it != _dataLayers.end(); ++it) {\n delete *it;\n }\n for (intv::const_iterator it = _deviceIDs.begin(); it != _deviceIDs.end(); ++it) {\n DEVICE_MEMORY_MANAGER::destroyInstance(*it);\n }\n HOST_MEMORY_MANAGER::destroyInstance();\n delete _sync;\n delete _dataCopyPD;\n delete _dp;\n}\n\nvoid ConvNet::stop() {\n getWorkerQueue().enqueue(new ExitWorker(*this));\n join();\n}\n\nPipeDispenser& ConvNet::getDataCopyPD() {\n return *_dataCopyPD;\n}\n\nvoid ConvNet::initDataLayers(PyObjectV* layerList) {\n for (int i = 0; i < layerList->size(); i++) {\n PyObject* paramsDict = layerList->at(i);\n std::string layerType = pyDictGetString(paramsDict, \"type\");\n\n if (layerType == \"data\") {\n int numReplicas = pyDictGetInt(paramsDict, \"numReplicas\");\n for (int r = 0; r < numReplicas; ++r) {\n DataLayer* dataLayer = new DataLayer(this, paramsDict, r);\n _dataLayers.push_back(dataLayer);\n _layerMap[dataLayer->getName()][r] = dataLayer;\n }\n }\n }\n}\n\nvoid ConvNet::initGPUThreads(PyObjectV* layerList) {\n // Initialize GPU worker threads\n for (int i = 0; i < _deviceIDs.size(); ++i) {\n ConvNetThread* cng = new ConvNetThread(layerList, _deviceIDs[i], i, this);\n _convNetThreads.push_back(cng);\n for (NameLayerMap::iterator it = cng->getLayerMap().begin(); it != cng->getLayerMap().end(); ++it) {\n const std::string& name = it->first;\n Layer* layer = it->second;\n _layerMap[name][layer->getReplicaID()] = layer;\n }\n }\n}\n\nvoid ConvNet::connectReplicas() {\n _numReplicasMax = 0;\n _numReplicasMin = 1 << 16;\n for (NameReplicaLayerMap::iterator it = _layerMap.begin(); it != _layerMap.end(); ++it) {\n _numReplicasMax = max(_numReplicasMax, int(it->second.size()));\n _numReplicasMin = min(_numReplicasMin, int(it->second.size()));\n for (map::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) {\n Layer& l1 = *it2->second;\n for (map::iterator it3 = it->second.begin(); it3 != it->second.end(); ++it3) {\n Layer& l2 = *it3->second;\n l1.addReplica(l2);\n }\n }\n }\n}\n\nvoid ConvNet::connectChildren(PyObject* layerParams) {\n for (NameReplicaLayerMap::iterator it = _layerMap.begin(); it != _layerMap.end(); ++it) {\n PyObject* paramsDict = PyDict_GetItemString(layerParams, it->first.c_str());\n PyObject* inputList = PyDict_GetItemString(paramsDict, \"inputs\");\n if (inputList != NULL) {\n // Iterate over \"replicas\" of this layer\n int numReplicas = _layerMap[it->first].size();\n for (int i = 0; i < PyList_GET_SIZE(inputList); i++) {\n std::string inputName = PyString_AsString(PyList_GetItem(inputList, i));\n int numReplicasPrev = _layerMap[inputName].size();\n // How many replicas from the previous layer must this layer be connected to?\n int numInputReplicas = numReplicasPrev / numReplicas;\n for (int r = 0; r < numReplicas; r++) {\n for (int rp = r, ridx = 0; ridx < numInputReplicas; rp += numReplicas, ridx++) {\n it->second[r]->addPrev(*_layerMap[inputName][rp], ridx);\n _layerMap[inputName][rp]->addNext(*it->second[r]);\n }\n }\n }\n }\n }\n}\n\nvoid ConvNet::findBwdTerminal(Layer& l, set& visited, int& terminal, int passIdx) {\n if (visited.count(&l) == 0) {\n visited.insert(&l);\n if (l.isGradConsumer()) {\n bool hasPrevConsumer = false;\n if (l.getPrev().size() > 0) {\n for (int i = 0; i < l.getPrev()[0].size(); i++) {\n // Looking only at 0th replica is fine to see if you have\n // grad consumers below you.\n hasPrevConsumer |= l.getPrev()[0][i]->isGradConsumer();\n }\n }\n if (!hasPrevConsumer || !l.isGradProducer() || (passIdx + 1 < l.getNumReplicasPrev() && l.getNumReplicasPrev() > l.getNumReplicas())) {\n terminal++;\n l.setBwdTerminal(passIdx);\n printf(\"found bwd terminal %s[%d] in passIdx=%d\\n\", l.getName().c_str(), l.getReplicaID(), passIdx);\n } else if (l.isGradProducer()) {\n for (int r = 0; r < l.getPrev().size(); r++) {\n for (int i = 0; i < l.getPrev()[r].size(); i++) {\n findBwdTerminal(*l.getPrev()[r][i], visited, terminal, passIdx);\n }\n }\n }\n }\n }\n}\n\nvoid* ConvNet::run() {\n for (vector::const_iterator it = _convNetThreads.begin(); it != _convNetThreads.end(); ++it) {\n (*it)->start();\n }\n // The manager thread defaults to using the GPU of the first worker.\n // Put more logic here if this is inappropriate.\n NVMatrix::setDeviceID(_convNetThreads[0]->getDeviceID());\n copyToGPU();\n bool exit = false;\n while (!exit) {\n Worker* worker = _workerQueue.dequeue();\n exit = worker->run();\n delete worker;\n }\n\n return NULL;\n}\n\nQueue& ConvNet::getWorkerQueue() {\n return _workerQueue;\n}\n\nQueue& ConvNet::getResultQueue() {\n return _resultQueue;\n}\n\nDataProvider& ConvNet::getDataProvider() {\n return *_dp;\n}\n\nLayer& ConvNet::getLayer(std::string& name, int replicaID) {\n return *_layerMap[name][replicaID];\n}\n\nvoid ConvNet::sendMessage(MESSAGES msg, bool sync) {\n sendMessage(new Message(msg), sync);\n}\n\nvoid ConvNet::sendMessage(Message* msg, bool sync) {\n for (int i = 0; i < _convNetThreads.size(); i++) {\n _convNetThreads[i]->getMessageQueue().enqueue(msg->clone());\n }\n\n delete msg;\n\n if (sync) {\n syncWithChildren();\n }\n}\n\nvoid ConvNet::copyToCPU() {\n sendMessage(COPY_TO_CPU, true);\n}\n\nvoid ConvNet::copyToGPU() {\n sendMessage(COPY_TO_GPU, false);\n}\n\nvoid ConvNet::updateWeights(int passIdx) {\n sendMessage(UPDATE_WEIGHTS, true);\n sendMessage(CONSTRAIN_WEIGHTS, true);\n}\n\nvoid ConvNet::reset(int passIdx) {\n sendMessage((passIdx % getNumPasses()) == 0 ? RESET : RESET_PASS_IDX, false);\n}\n\nvoid ConvNet::reset() {\n reset(0);\n}\n\n// Fprop given data\nvoid ConvNet::fprop(CPUData& data, int passIdx, PASS_TYPE passType) {\n reset(passIdx);\n // This is necessary because setData below could delete data. If there's\n // an outstanding copy request, this'll cause a segfault.\n for (int i = 0; i < _dataLayers.size(); i++) {\n _dataLayers[i]->waitForCopyFinish();\n }\n\n setData(data, passIdx);\n for (int i = 0; i < _dataLayers.size(); i++) {\n _dataLayers[i]->fprop(passType, passIdx, false);\n }\n waitForTerminals(_numFwdTerminal, FPROP_TERMINAL);\n}\n\n// Fprop given minibatch idx\nvoid ConvNet::fprop(int miniIdx, int passIdx, PASS_TYPE passType) {\n reset(passIdx);\n\n bool fromBuffer = miniIdx == _bufferMinibatchIdx && passIdx == _bufferPassIdx;\n if (!fromBuffer) {\n // This is necessary because setData below could delete data. If there's\n // an outstanding copy request, this'll cause a segfault.\n for (int i = 0; i < _dataLayers.size(); i++) {\n _dataLayers[i]->waitForCopyFinish();\n }\n\n setData(_dp->getMinibatch(miniIdx), passIdx);\n\n } else {\n setDataFromBuffer();\n }\n for (int i = 0; i < _dataLayers.size(); i++) {\n _dataLayers[i]->fprop(passType, passIdx, fromBuffer);\n }\n\n if (passIdx == getNumPasses() - 1) {\n // Do double-buffering from next minibatch from the DataProvider\n setBuffer(miniIdx == _dp->getNumMinibatches() - 1 ? NULL : &_dp->getMinibatch(miniIdx + 1), miniIdx + 1, 0);\n } else {\n // Do double-buffering from next microbatch within current minibatch\n setBuffer(_data, miniIdx, passIdx + 1);\n }\n\n waitForTerminals(_numFwdTerminal, FPROP_TERMINAL);\n}\n\nvoid ConvNet::setDataFromBuffer() {\n if (_bufferData != _data) {\n delete _data;\n }\n _data = _bufferData;\n _bufferData = NULL;\n _bufferMinibatchIdx = -1;\n _bufferPassIdx = -1;\n}\n\nvoid ConvNet::setData(CPUData& data, int passIdx) {\n bool same = _data == _bufferData;\n if (&data != _data) {\n delete _data;\n }\n if (&data != _bufferData && !same) {\n delete _bufferData;\n _bufferData = NULL;\n _bufferMinibatchIdx = -1;\n _bufferPassIdx = -1;\n }\n _data = &data;\n for (int i = 0; i < _dataLayers.size(); i++) {\n _dataLayers[i]->copyData(*_data, false, passIdx);\n }\n}\n\nvoid ConvNet::setBuffer(CPUData* bufferData, int bufferMinibatchIdx, int bufferPassIdx) {\n _bufferData = bufferData;\n _bufferMinibatchIdx = bufferMinibatchIdx;\n _bufferPassIdx = bufferPassIdx;\n if (bufferData != NULL) {\n for (int i = 0; i < _dataLayers.size(); i++) {\n _dataLayers[i]->copyData(*_bufferData, true, bufferPassIdx);\n }\n }\n}\n\nCPUData& ConvNet::getData() {\n assert(_data != NULL);\n return *_data;\n}\n\nvoid ConvNet::bprop(int passIdx, PASS_TYPE passType) {\n _totalPassesDone++;\n sendMessage(new BpropStartMessage(passType, passIdx), false);\n waitForTerminals(_numBwdTerminal[passIdx], BPROP_TERMINAL);\n reset(passIdx + 1);\n}\n\nvoid ConvNet::waitForTerminals(int numMsgs, MESSAGES msgType) {\n for (int rcvd = 0; rcvd < numMsgs; rcvd++) {\n Message* m = _msgQueue.dequeue();\n assert(m->getType() == msgType);\n delete m;\n }\n}\n\n// Same as getCost() but adds results to given cost and returns it\nCost& ConvNet::getCost(Cost& cost) {\n Cost &tmp = getCost();\n cost += tmp;\n delete &tmp;\n return cost;\n}\n\nCost& ConvNet::getCost() {\n Cost& cost = *new Cost();\n for (int t = 0; t < _convNetThreads.size(); t++) {\n Cost& tcost = _convNetThreads[t]->getCost();\n cost += tcost;\n delete &tcost;\n }\n return cost;\n}\n\ndouble ConvNet::getCostValue() {\n Cost& cost = getCost();\n double val = cost.getValue();\n delete &cost;\n return val;\n}\n\nQueue& ConvNet::getMessageQueue() {\n return _msgQueue;\n}\n\nintv& ConvNet::getDeviceIDs() {\n return _deviceIDs;\n}\n\nThreadSynchronizer& ConvNet::getSync() {\n return *_sync;\n}\n\nvoid ConvNet::syncWithChildren() {\n sendMessage(SYNC, false);\n _sync->sync();\n}\n\nint ConvNet::getTotalPassesDone() {\n return _totalPassesDone;\n}\n\nint ConvNet::getMinibatchSize() {\n return _dp->getMinibatchSize();\n}\n\nint ConvNet::getNumReplicasMax() {\n return _numReplicasMax;\n}\n\nint ConvNet::getNumReplicasMin() {\n return _numReplicasMin;\n}\n\nint ConvNet::getNumPasses() {\n return _numReplicasMax / _numReplicasMin;\n}\n\nvoid ConvNet::setTrainingProgress(double progress) {\n _trainingProgress = progress;\n}\n\ndouble ConvNet::getTrainingProgress() const {\n return _trainingProgress;\n}\n\nbool ConvNet::isConserveMemory() {\n return _conserveMem;\n}\n\n/*\n * Gradient checking stuff\n */\nvoid ConvNet::checkGradients() {\n _numFailures = 0;\n _numTests = 0;\n _baseErr = 0;\n for (int p = 0; p < getNumPasses(); ++p) {\n fprop(0, p, PASS_GC);\n _baseErr += getCostValue();\n bprop(p, PASS_GC);\n }\n // We call grad check only on the first replica,\n // but because weights are aware of their fellow replicas,\n // we can simultaneously perturb the weights of all\n // replicas.\n for (NameReplicaLayerMap::iterator it = _layerMap.begin(); it != _layerMap.end(); ++it) {\n map& layers = it->second;\n if (layers[0]->getDeviceID() >= 0 /*&& (layers[0]->getName() == \"fc10\")*/) { // If layer on GPU (data layers aren't)\n layers[0]->checkGradient();\n }\n }\n\n cout << \"------------------------\" << endl;\n if (_numFailures > 0) {\n cout << _numFailures << \"/\" << _numTests << \" TESTS FAILED\" << endl;\n } else {\n cout << \"ALL \" << _numTests << \" TESTS PASSED\" << endl;\n }\n}\n\n// Copies to all replicas\nvoid ConvNet::checkGradient_copyWeightsToGPU(Matrix& weightsCPU, Weights& weights) {\n int d = NVMatrix::getDeviceID();\n for (map::const_iterator it = weights.getReplicas().begin(); it != weights.getReplicas().end(); ++it) {\n NVMatrix::setDeviceID(it->second->getDeviceID());\n it->second->getW().copyFromHost(weightsCPU);\n }\n NVMatrix::setDeviceID(d);\n}\n\n/*\n * name: weight matrix name\n * eps: finite difference step\n */\nbool ConvNet::checkGradient(const std::string& name, float eps, Weights& weights) {\n Matrix numGrad(weights.getNumRows(), weights.getNumCols());\n Matrix diff(numGrad);\n numGrad.apply(Matrix::ZERO);\n Matrix weightsCPU;\n\n weights.getW().copyToHost(weightsCPU, true);\n\n for(int i = 0; i < weights.getNumRows(); i++) {\n for (int j = 0; j < weights.getNumCols(); j++) {\n float v = weightsCPU(i,j);\n weightsCPU(i,j) += eps;\n\n checkGradient_copyWeightsToGPU(weightsCPU, weights);\n\n weightsCPU(i,j) = v;\n double err = 0;\n for (int p = 0; p < getNumPasses(); ++p) {\n// printf(\"trying fprop %d\\n\", p);\n fprop(0, p, PASS_GC);\n// printf(\" success\\n\");\n err += getCostValue();\n }\n numGrad(i,j) = (err - _baseErr) / (_data->getNumCases() * eps);\n if (isnan((double)numGrad(i,j)) || isinf((double)numGrad(i,j))) {\n cout << \"Numerical computation produced nan or inf when checking '\" << name << \"': \" << numGrad(i,j) << endl;\n cout << \"Consider reducing the sizes of the weights or finite difference steps.\" << endl;\n cout << \"Exiting.\" << endl;\n exit(1);\n }\n checkGradient_copyWeightsToGPU(weightsCPU, weights);\n }\n }\n Matrix gradCPU;\n NVMatrix::setDeviceID(weights.getDeviceID());\n map mats;\n for (map::const_iterator it = weights.getReplicas().begin(); it != weights.getReplicas().end(); ++it) {\n mats[it->first] = &it->second->getGrad();\n }\n weights.getReducer().reduce(mats, 1, false);\n\n weights.getGrad().copyToHost(gradCPU, true);\n gradCPU.scale(-1.0 / _data->getNumCases());\n float analNorm = gradCPU.norm();\n float numNorm = numGrad.norm();\n numGrad.subtract(gradCPU, diff);\n float relErr = diff.norm() / analNorm;\n bool fail = relErr >= GC_REL_ERR_THRESH;\n if (fail || !GC_SUPPRESS_PASSES) {\n cout << \"========================\" << endl;\n printf(\"(%s) %s GRADIENT CHECK\\n\", fail ? \"****FAIL****\" : \"PASS\", name.c_str());\n cout << \"========================\" << endl;\n cout << \"Analytic:\" << endl;\n gradCPU.print(0, 6, 0, 4);\n cout << \"Numeric:\" << endl;\n numGrad.print(0, 6, 0, 4);\n printf(\"Analytic norm: %e\\n\", analNorm);\n printf(\"Numeric norm: %e\\n\", numNorm);\n printf(\"Relative error: %e\\n\", relErr);\n }\n _numTests++;\n _numFailures += fail;\n return fail;\n}\n\n/* \n * =======================================================================================================\n * ConvNetThread\n * =======================================================================================================\n */\nConvNetThread::ConvNetThread(PyObjectV* layerList, int deviceID, int deviceIdx, ConvNet* convNet)\n : Thread(true, getDeviceCPUs(deviceID)), _deviceID(deviceID), _convNet(convNet) {\n try {\n int numLayers = layerList->size();\n\n for (int i = 0; i < numLayers; i++) {\n PyObject* paramsDict = layerList->at(i);\n std::string layerType = pyDictGetString(paramsDict, \"type\");\n if (layerType != \"data\") {\n intv& gpus = *pyDictGetIntV(paramsDict, \"gpu\");\n int rid = indexOf(gpus, deviceIdx);\n if (rid >= 0) {\n initLayer(paramsDict, rid);\n }\n delete &gpus;\n }\n }\n } catch (std::string& s) {\n cout << \"Error creating ConvNet: \" << s << endl;\n exit(1);\n }\n}\n\nConvNetThread::~ConvNetThread() {\n NVMatrix::setDeviceID(_deviceID);\n NVMatrix::destroyCublas();\n NVMatrix::destroyRandom();\n for (NameLayerMap::const_iterator it = _nameLayerMap.begin(); it != _nameLayerMap.end(); ++it) {\n delete it->second;\n }\n _nameLayerMap.clear();\n}\n\nvoid ConvNetThread::startTimer() {\n NVMatrix::syncStream();\n _timer.start();\n}\n\ndouble ConvNetThread::stopTimer() {\n NVMatrix::syncStream();\n return _timer.stop();\n}\n\nvoid ConvNetThread::initLayer(PyObject* paramsDict, int replicaID) {\n std::string type = pyDictGetString(paramsDict, \"type\");\n std::string name = pyDictGetString(paramsDict, \"name\");\n if (type == \"fc\") {\n _nameLayerMap[name] = new FCLayer(this, paramsDict, replicaID, false);\n } else if (type == \"sfc\") {\n _nameLayerMap[name] = new SplitFCLayer(this, paramsDict, replicaID, false);\n } else if (type == \"conv\") {\n _nameLayerMap[name] = new ConvLayer(this, paramsDict, replicaID);\n } else if (type == \"local\") {\n _nameLayerMap[name] = new LocalUnsharedLayer(this, paramsDict, replicaID);\n } else if (type == \"pool\") {\n _nameLayerMap[name] = &PoolLayer::make(this, paramsDict, replicaID);\n } else if (type == \"cmpool\") {\n _nameLayerMap[name] = &CrossMapPoolLayer::make(this, paramsDict, replicaID);\n } else if (type == \"rnorm\") {\n _nameLayerMap[name] = new ResponseNormLayer(this, paramsDict, replicaID);\n } else if (type == \"cmrnorm\") {\n _nameLayerMap[name] = new CrossMapResponseNormLayer(this, paramsDict, replicaID);\n } else if (type == \"cnorm\") {\n _nameLayerMap[name] = new ContrastNormLayer(this, paramsDict, replicaID);\n } else if (type == \"softmax\") {\n _nameLayerMap[name] = new SoftmaxLayer(this, paramsDict, replicaID);\n } else if (type == \"eltsum\") {\n _nameLayerMap[name] = new EltwiseSumLayer(this, paramsDict, replicaID);\n } else if (type == \"eltmax\") {\n _nameLayerMap[name] = new EltwiseMaxLayer(this, paramsDict, replicaID);\n } else if (type == \"neuron\") {\n _nameLayerMap[name] = new NeuronLayer(this, paramsDict, replicaID);\n } else if (type == \"nailbed\") {\n _nameLayerMap[name] = new NailbedLayer(this, paramsDict, replicaID);\n } else if (type == \"blur\") {\n _nameLayerMap[name] = new GaussianBlurLayer(this, paramsDict, replicaID);\n } else if (type == \"href\") {\n _nameLayerMap[name] = new HorizontalReflectionLayer(this, paramsDict, replicaID);\n } else if (type == \"resize\") {\n _nameLayerMap[name] = new ResizeLayer(this, paramsDict, replicaID);\n } else if (type == \"rgb2yuv\") {\n _nameLayerMap[name] = new RGBToYUVLayer(this, paramsDict, replicaID);\n } else if (type == \"rgb2lab\") {\n _nameLayerMap[name] = new RGBToLABLayer(this, paramsDict, replicaID);\n } else if (type == \"rscale\") {\n _nameLayerMap[name] = new RandomScaleLayer(this, paramsDict, replicaID);\n } else if (type == \"crop\") {\n _nameLayerMap[name] = new CropLayer(this, paramsDict, replicaID);\n } else if (type == \"concat\") {\n _nameLayerMap[name] = new ConcatenationLayer(this, paramsDict, replicaID);\n } else if (type == \"pass\") {\n _nameLayerMap[name] = new PassThroughLayer(this, paramsDict, replicaID);\n } else if (type == \"dropout\") {\n _nameLayerMap[name] = new DropoutLayer(this, paramsDict, replicaID);\n } else if (type == \"dropout2\") {\n _nameLayerMap[name] = new Dropout2Layer(this, paramsDict, replicaID);\n } else if (strncmp(type.c_str(), \"cost.\", 5) == 0) {\n CostLayer *c = &CostLayer::make(this, paramsDict, type, replicaID);\n _nameLayerMap[name] = c;\n _costs.push_back(c);\n } else {\n throw std::string(\"Unknown layer type \") + type;\n }\n}\n\n/*\n * This executes in a new CPU thread so it's OK to initialize CUDA stuff here. \n */\nvoid ConvNetThread::initCuda() { \n NVMatrix::setDeviceID(_deviceID);\n checkCudaErrors(cudaDeviceSetCacheConfig(cudaFuncCachePreferShared));\n for (int i = 0; i < _convNet->getDeviceIDs().size(); i++) {\n int d = _convNet->getDeviceIDs()[i];\n if (d != _deviceID) {\n if (NVMatrix::canAccessPeer(_deviceID, d)) {\n printf(\"Enabling peer access GPU %d --> GPU %d\\n\", NVMatrix::getDeviceID(), d);\n checkCudaErrors(cudaDeviceEnablePeerAccess(d, 0));\n } else {\n printf(\"No peer access GPU %d --> GPU %d\\n\", _deviceID, d);\n }\n }\n }\n// NVMatrix::syncStream();\n NVMatrix::initCublas();\n NVMatrix::initRandom(/*7*/);\n srand(time(0));\n}\n\nvoid* ConvNetThread::run() {\n initCuda();\n bool exit = false;\n while (!exit) {\n Message* m = _msgQueue.dequeue();\n if (m->getType() == FPROP_READY) {\n FpropMessage* msg = static_cast(m);\n msg->getToLayer().fprop(msg->getPassType(), msg->getPassIdx());\n } else if (m->getType() == BPROP_READY) {\n BpropMessage* msg = static_cast(m);\n msg->getToLayer().incRcvdBInputMsgs();\n msg->getToLayer().bprop(msg->getPassType(), msg->getPassIdx());\n } else if (m->getType() == BPROP_START) {\n BpropStartMessage* msg = static_cast(m);\n for (int i = 0; i < _costs.size(); i++) {\n dynamic_cast(_costs[i])->bprop(msg->getPassType(), msg->getPassIdx());\n }\n } else if (m->getType() == SYNC) {\n NVMatrix::syncStream();\n _convNet->getSync().sync();\n } else if (m->getType() == COPY_TO_CPU) {\n for (NameLayerMap::iterator it = _nameLayerMap.begin(); it != _nameLayerMap.end(); ++it) {\n it->second->copyToCPU();\n }\n } else if (m->getType() == COPY_TO_GPU) {\n for (NameLayerMap::iterator it = _nameLayerMap.begin(); it != _nameLayerMap.end(); ++it) {\n it->second->copyToGPU();\n }\n } else if (m->getType() == RESET) {\n for (NameLayerMap::iterator it = _nameLayerMap.begin(); it != _nameLayerMap.end(); ++it) {\n it->second->reset();\n }\n } else if (m->getType() == RESET_PASS_IDX) {\n for (NameLayerMap::iterator it = _nameLayerMap.begin(); it != _nameLayerMap.end(); ++it) {\n it->second->resetPassIdx();\n }\n } else if (m->getType() == UPDATE_WEIGHTS) {\n for (NameLayerMap::iterator it = _nameLayerMap.begin(); it != _nameLayerMap.end(); ++it) {\n it->second->updateWeights();\n }\n } else if (m->getType() == CONSTRAIN_WEIGHTS) {\n for (NameLayerMap::iterator it = _nameLayerMap.begin(); it != _nameLayerMap.end(); ++it) {\n it->second->constrainWeights();\n }\n } else if (m->getType() == EXIT_CONVNET) {\n exit = true;\n }\n delete m;\n }\n return NULL;\n}\n\nCost& ConvNetThread::getCost() {\n // In a single ConvNetThread, all costs are guaranteed to be different\n // (i.e. not replicas of one another)\n return *new Cost(_costs);\n}\n\nLayer& ConvNetThread::getLayer(std::string& name) {\n return *_nameLayerMap[name];\n}\n\nint ConvNetThread::getDeviceID() {\n return _deviceID;\n}\n\nQueue& ConvNetThread::getMessageQueue() {\n return _msgQueue;\n}\n\nvector& ConvNetThread::getCostLayers() {\n return _costs;\n}\n\nNameLayerMap& ConvNetThread::getLayerMap() {\n return _nameLayerMap;\n}\n\nConvNet& ConvNetThread::getConvNet() {\n return *_convNet;\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/copypipeline.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/copypipeline.cuh\"\n//#include \"gpu_util.cuh\"\n\nusing namespace std;\n\n/* =========================\n * ICopySegment\n * =========================\n */\nICopySegment::ICopySegment(IBroadcastNetwork& parent, int deviceID, Queue* finishQueue)\n : _parent(&parent), _prev(NULL), _stream(NULL), _deviceID(deviceID), _finishQueue(finishQueue), Thread(true, getDeviceCPUs(parent.getSourceDeviceID())) {\n _execDeviceID = _deviceID;\n}\n\nICopySegment::~ICopySegment() {\n if (_stream != NULL) {\n checkCudaErrors(cudaStreamDestroy(_stream));\n }\n}\n\nvoid* ICopySegment::run() {\n assert(_execDeviceID != DEVICE_HOST);\n NVMatrix::setDeviceID(_execDeviceID);\n checkCudaErrors(cudaStreamCreateWithFlags(&_stream, cudaStreamNonBlocking));\n bool exit = false;\n while (!exit) {\n CopyMessage& msg = *_queue.dequeue();\n if (msg.getType() == CopyMessage::EXIT) {\n exit = true;\n } else {\n bool term = processMessage(msg);\n if (term) {\n assert(_finishQueue != NULL);\n _finishQueue->enqueue(1);\n }\n }\n delete &msg;\n }\n return NULL;\n}\n\nNVMatrix& ICopySegment::getChunk(NVMatrix& mat, int chunkSize, int chunkIdx) {\n NVMatrix& line = mat.reshaped(1, mat.getNumElements());\n int start = chunkIdx * chunkSize;\n int end = min((chunkIdx+1) * chunkSize, mat.getNumElements());\n NVMatrix& chunk = line.sliceCols(start, end);\n delete &line;\n return chunk;\n}\n\ninline NVMatrix& ICopySegment::getMatrix(CopyMessage& msg) {\n if (getDeviceID() == DEVICE_HOST) {\n return _hmat;\n }\n return msg.getMatrix(getDeviceID());\n}\n\nQueue& ICopySegment::getQueue() {\n return _queue;\n}\n\ninline int ICopySegment::getDeviceID() {\n return _deviceID;\n}\n\nvoid ICopySegment::addPrev(ICopySegment& c) {\n _prev = &c;\n if (_deviceID == DEVICE_HOST) {\n _execDeviceID = c.getDeviceID();\n }\n}\n\nvoid ICopySegment::addNext(CopyPeer& c) {\n _next.push_back(&c);\n c.addPrev(*this);\n}\n\nbool ICopySegment::isTerminal() const {\n return _next.size() == 0;\n}\n\n/* =========================\n * CopySource\n * =========================\n */\nCopySource::CopySource(IBroadcastNetwork& parent, int deviceID) : ICopySegment(parent, deviceID, NULL) {\n}\n\nbool CopySource::processMessage(CopyMessage& msg) {\n assert(msg.getType() == CopyMessage::COPY_START);\n int numChunks = min(getMatrix(msg).getNumElements(), max(COPY_MIN_CHUNKS, min(COPY_MAX_CHUNKS, DIVUP(getMatrix(msg).getNumElements(), COPY_MIN_CHUNK_SIZE))));\n int chunkSize = DIVUP(getMatrix(msg).getNumElements(), numChunks);\n// printf(\"num chunks: %d\\n\", numChunks);\n for (int c = 0; c <= numChunks; ++c) {\n for (vector::const_iterator it = _next.begin(); it != _next.end(); ++it) {\n (*it)->getQueue().enqueue(new CopyChunkMessage(c, chunkSize, numChunks, msg.getScaleSource(), msg.getScaleTargets(), msg.getMatrices()));\n }\n }\n return false;\n}\n\ninline bool CopySource::isSource() const {\n return true;\n}\n\n/* =========================\n * CopyPeer\n * =========================\n */\nCopyPeer::CopyPeer(IBroadcastNetwork& parent, int deviceID, Queue* finishQueue) : ICopySegment(parent, deviceID, finishQueue) {\n}\n\nbool CopyPeer::processMessage(CopyMessage& msg) {\n assert(msg.getType() == CopyMessage::COPY_CHUNK);\n CopyChunkMessage& cmsg = *static_cast(&msg);\n if (cmsg.getChunkIdx() < cmsg.getNumChunks()) {\n if (!isTerminal() || (isTerminal() && msg.getScaleTargets() == 0)) {\n getMatrix(msg).resize(_prev->getMatrix(msg));\n }\n// getMatrix(msg).printShape(\"getMatrix(msg)\");\n// _prev->getMatrix(msg).printShape(\"_prev->getMatrix(msg)\");\n assert(getMatrix(msg).isSameDims(_prev->getMatrix(msg)));\n const float scaleSelf = isTerminal() ? msg.getScaleTargets() : 0;\n const float scalePrev = _prev->isSource() ? msg.getScaleSource() : 1;\n NVMatrix& prevChunk = getChunk(_prev->getMatrix(msg), cmsg.getChunkSize(), cmsg.getChunkIdx());\n NVMatrix& myChunk = getChunk(getMatrix(msg), cmsg.getChunkSize(), cmsg.getChunkIdx());\n prevChunk.add(myChunk, scalePrev, scaleSelf, myChunk, _stream);\n NVMatrix::syncStream(_stream);\n delete &prevChunk;\n delete &myChunk;\n }\n for (vector::const_iterator it = _next.begin(); it != _next.end(); ++it) {\n (*it)->getQueue().enqueue(new CopyChunkMessage(cmsg));\n }\n return cmsg.getChunkIdx() >= cmsg.getNumChunks() && isTerminal();\n}\n\ninline bool CopyPeer::isSource() const {\n return false;\n}\n\n/* =========================\n * IBroadcastNetwork\n * =========================\n */\nIBroadcastNetwork& IBroadcastNetwork::make(set devices, int srcDevice) {\n if (devices.size() == 8) {\n return (new EightGPUBroadcaster1(devices, srcDevice))->construct();\n } else if (devices.size() == 1) {\n return (new NullBroadcaster(devices, srcDevice))->construct();\n } else if (devices.size() == 2 && NVMatrix::canAccessPeer(*devices.begin(), *(++devices.begin()))) {\n return (new TwoPeeringGPUsBroadcaster(devices, srcDevice))->construct();\n }\n return (new NaiveBroadcaster(devices, srcDevice))->construct();\n}\n\nIBroadcastNetwork::IBroadcastNetwork(set& devices, int srcDeviceID, int numTerminal)\n : _devices(devices), _srcDeviceID(srcDeviceID), _numTerminal(numTerminal), _constructed(false), _src(NULL) {\n}\n\nIBroadcastNetwork::~IBroadcastNetwork() {\n vector v;\n v.insert(v.end(), _peers.begin(), _peers.end());\n v.insert(v.end(), _src);\n for (vector::const_iterator it = v.begin(); it != v.end(); ++it) {\n (*it)->getQueue().enqueue(new CopyMessage(CopyMessage::EXIT));\n (*it)->join();\n delete *it;\n }\n}\n\nIBroadcastNetwork& IBroadcastNetwork::construct() {\n assert(!_constructed);\n pair,vector > gpus = makeGPULists();\n _src = new CopySource(*this, _srcDeviceID);\n makePeers(gpus);\n makeConnections();\n _src->start();\n for (vector::const_iterator it = _peers.begin(); it != _peers.end(); ++it) {\n (*it)->start();\n }\n _constructed = true;\n return *this;\n}\n\npair,vector > IBroadcastNetwork::makeGPULists() {\n vector same, other;\n for (set::const_iterator it = _devices.begin(); it != _devices.end(); ++it) {\n if (*it != _srcDeviceID) {\n if (NVMatrix::canAccessPeer(_srcDeviceID, *it)) {\n same.insert(same.begin() + rand() % (1 + same.size()), *it);\n } else {\n other.insert(other.begin() + rand() % (1 + other.size()), *it);\n }\n }\n }\n return pair,vector >(same, other);\n}\n\nvoid IBroadcastNetwork::broadcast(std::map& mats) {\n _broadcast(mats, 1, 0);\n}\n\nvoid IBroadcastNetwork::_broadcast(std::map& mats, float scaleSource, float scaleTargets) {\n assert(_constructed);\n assert(_finishQueue.getNumElements() == 0);\n assert(mats.size() == _devices.size());\n assert(mats.size() > 1);\n if (mats[_srcDeviceID]->getNumElements() == 0) {\n for (map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n it->second->resize(*mats[_srcDeviceID]);\n }\n } else {\n _src->getQueue().enqueue(new CopyStartMessage(scaleSource, scaleTargets, mats));\n for (int i = 0; i < _numTerminal; ++i) {\n _finishQueue.dequeue();\n }\n }\n assert(_finishQueue.getNumElements() == 0);\n}\n\nint IBroadcastNetwork::getSourceDeviceID() const {\n return _srcDeviceID;\n}\n\nvoid IBroadcastNetwork::makePeers(pair,vector >& gpus) {\n vector& same = gpus.first, &other = gpus.second;\n for (int i = 0; i < same.size(); ++i) {\n _peers.push_back(new CopyPeer(*this, same[i], &_finishQueue));\n }\n for (int i = 0; i < other.size(); ++i) {\n _peers.push_back(new CopyPeer(*this, other[i], &_finishQueue));\n }\n _peers.push_back(new CopyPeer(*this, DEVICE_HOST, &_finishQueue)); // peers[7]\n}\n\n/* =========================\n * ISafeBroadcastNetwork\n * =========================\n */\nISafeBroadcastNetwork& ISafeBroadcastNetwork::make(set devices, int srcDevice) {\n if (devices.size() == 1) {\n return (new NullBroadcaster(devices, srcDevice))->construct();\n } else if (devices.size() == 2 && NVMatrix::canAccessPeer(*devices.begin(), *(++devices.begin()))) {\n return (new TwoPeeringGPUsBroadcaster(devices, srcDevice))->construct();\n }\n return (new NaiveBroadcaster(devices, srcDevice))->construct();\n}\n\nISafeBroadcastNetwork::ISafeBroadcastNetwork(std::set& devices, int srcDeviceID, int numTerminal) : IBroadcastNetwork(devices, srcDeviceID, numTerminal) {\n}\n\nvoid ISafeBroadcastNetwork::broadcast(std::map& mats, float scaleSource, float scaleTargets) {\n _broadcast(mats, scaleSource, scaleTargets);\n}\n\nISafeBroadcastNetwork& ISafeBroadcastNetwork::construct() {\n IBroadcastNetwork::construct();\n return *this;\n}\n\n/* =========================\n * NullBroadcaster\n * =========================\n */\nNullBroadcaster::NullBroadcaster(std::set& devices, int srcDeviceID) : ISafeBroadcastNetwork(devices, srcDeviceID, 0) {\n}\n\nvoid NullBroadcaster::makeConnections() {\n}\n\nNullBroadcaster& NullBroadcaster::construct() {\n _constructed = true;\n return *this;\n}\n\nvoid NullBroadcaster::broadcast(std::map& mats, float scaleSource, float scaleTargets) {\n}\n\nvoid NullBroadcaster::broadcast(std::map& mats) {\n}\n\n/* =========================\n * NaiveBroadcaster\n * =========================\n *\n * This one does src -> host -> all\n */\nNaiveBroadcaster::NaiveBroadcaster(std::set& devices, int srcDeviceID) : ISafeBroadcastNetwork(devices, srcDeviceID, devices.size()-1) {\n}\n\nvoid NaiveBroadcaster::makeConnections() {\n _src->addNext(*_peers.back()); // Make connection src -> host\n for (int i = 0; i < _peers.size() - 1; ++i) {\n if (_peers[i]->getDeviceID() != _src->getDeviceID()) {\n _peers.back()->addNext(*_peers[i]); // Make connection host -> peer\n }\n }\n}\n\n/* =========================\n * EightGPUBroadcaster1\n * =========================\n *\n * This one does a fancy graph\n */\nEightGPUBroadcaster1::EightGPUBroadcaster1(set& devices, int srcDeviceID) : IBroadcastNetwork(devices, srcDeviceID, 4) {\n}\n\nvoid EightGPUBroadcaster1::makeConnections() {\n _src->addNext(*_peers[7]);\n _peers[7]->addNext(*_peers[0]);\n _peers[7]->addNext(*_peers[1]);\n _peers[7]->addNext(*_peers[3]);\n _peers[7]->addNext(*_peers[4]);\n\n _peers[1]->addNext(*_peers[2]);\n _peers[3]->addNext(*_peers[5]);\n _peers[4]->addNext(*_peers[6]);\n}\n\n/* =========================\n * TwoPeeringGPUsBroadcaster\n * =========================\n */\nTwoPeeringGPUsBroadcaster::TwoPeeringGPUsBroadcaster(std::set& devices, int srcDeviceID) : ISafeBroadcastNetwork(devices, srcDeviceID, 0) {\n _tgtDeviceID = *devices.begin() == srcDeviceID ? *(++devices.begin()) : *devices.begin();\n}\n\nTwoPeeringGPUsBroadcaster::~TwoPeeringGPUsBroadcaster() {\n if (_constructed) {\n checkCudaErrors(cudaStreamDestroy(_tgtStream));\n }\n}\n\nvoid TwoPeeringGPUsBroadcaster::makeConnections() {\n}\n\nvoid TwoPeeringGPUsBroadcaster::resetDeviceID(int d) {\n if (d >= 0) {\n NVMatrix::setDeviceID(d);\n }\n}\n\nISafeBroadcastNetwork& TwoPeeringGPUsBroadcaster::construct() {\n assert(!_constructed);\n int d = NVMatrix::getDeviceID();\n NVMatrix::setDeviceID(_tgtDeviceID);\n checkCudaErrors(cudaStreamCreateWithFlags(&_tgtStream, cudaStreamNonBlocking));\n resetDeviceID(d);\n _constructed = true;\n return *this;\n}\n\nvoid TwoPeeringGPUsBroadcaster::_broadcast(std::map& mats, float scaleSource, float scaleTargets) {\n int d = NVMatrix::getDeviceID();\n NVMatrix::setDeviceID(_tgtDeviceID);\n mats[_tgtDeviceID]->add(*mats[_srcDeviceID], scaleTargets, scaleSource, *mats[_tgtDeviceID], _tgtStream);\n NVMatrix::syncStream(_tgtStream);\n resetDeviceID(d);\n}\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/cost.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \"../include/cost.cuh\"\n\nusing namespace std;\n\n/* \n * =====================\n * Cost\n * =====================\n */\n\nCost::Cost() {\n}\n\nCost::Cost(vector& costs) {\n for (vector::iterator it = costs.begin(); it != costs.end(); ++it) {\n _costMap[(*it)->getName()] = &(*it)->getCost();\n _costCoeffMap[(*it)->getName()] = (*it)->getCoeff();\n _numCases[(*it)->getName()] = (*it)->getNumCases();\n }\n}\n\nint Cost::getNumCases() {\n return _numCases.size() == 0 ? 0 : _numCases.begin()->second;\n}\n\nmap& Cost::getNumCasesMap() {\n return _numCases;\n}\n\ndoublev& Cost::operator [](const std::string s) {\n return *_costMap[s];\n}\n\nCostMap& Cost::getCostMap() {\n return _costMap;\n}\n\nCostCoeffMap& Cost::getCostCoeffMap() {\n return _costCoeffMap;\n}\n\ndouble Cost::getValue() {\n double val = 0;\n for (CostMap::iterator it = _costMap.begin(); it != _costMap.end(); ++it) {\n val += _costCoeffMap[it->first] * (it->second->size() == 0 ? 0 : it->second->at(0));\n }\n return val;\n}\n\nCost& Cost::operator += (Cost& er) {\n CostMap& otherMap = er.getCostMap();\n CostCoeffMap& otherCoeffMap = er.getCostCoeffMap();\n\n for (CostMap::const_iterator it = otherMap.begin(); it != otherMap.end(); ++it) {\n bool newCost = _costMap.count(it->first) == 0;\n if (newCost) {\n _costMap[it->first] = new doublev();\n _costCoeffMap[it->first] = otherCoeffMap[it->first];\n _numCases[it->first] = er.getNumCasesMap()[it->first];\n } else {\n _numCases[it->first] += er.getNumCasesMap()[it->first];\n }\n \n doublev& myVec = *_costMap[it->first];\n doublev& otherVec = *otherMap[it->first];\n assert(myVec.size() == 0 || otherVec.size() == 0 || myVec.size() == otherVec.size());\n // Add costs from otherVec to me\n for (int i = 0; i < otherVec.size(); i++) {\n if (myVec.size() <= i) {\n myVec.push_back(0);\n }\n myVec[i] += otherVec[i];\n }\n }\n return *this;\n}\n\nCost::~Cost() {\n for (CostMap::const_iterator it = _costMap.begin(); it != _costMap.end(); ++it) {\n delete it->second;\n }\n}\n\nvoid Cost::print() {\n for (CostMap::const_iterator it = _costMap.begin(); it != _costMap.end(); ++it) {\n printf(\"%s (%.3f): \", it->first.c_str(), _costCoeffMap[it->first]);\n doublev& vec = *_costMap[it->first];\n for (int z = 0; z < vec.size(); ++z) {\n printf(\"%.3f\", vec[z]);\n if (z < vec.size() - 1) {\n printf(\", \");\n }\n }\n printf(\"\\n\");\n }\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/data.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \"../../util/include/matrix.h\"\n#include \"../include/data.cuh\"\n#include \"../include/timer.cuh\"\n\nusing namespace std;\n\nDataProvider::DataProvider(int minibatchSize) : \n _minibatchSize(minibatchSize), _hData(NULL) {\n}\n\nvoid DataProvider::clearData() {\n delete _hData;\n _hData = NULL;\n}\n\nvoid DataProvider::setData(CPUData& hData) {\n // DataWorker calls clearData\n _hData = &hData;\n assert(_hData != NULL);\n}\n\nCPUData& DataProvider::getMinibatch(int idx) {\n assert(idx >= 0 && idx < getNumMinibatches());\n return getDataSlice(idx * _minibatchSize, (idx + 1) * _minibatchSize);\n}\n\nCPUData& DataProvider::getDataSlice(int startCase, int endCase) {\n assert(_hData != 0);\n assert(_hData->getNumCases() > 0);\n endCase = min(_hData->getNumCases(), endCase);\n // TODO: maintain these matrices, no point re-creating them all the time\n MatrixV& miniData = *new MatrixV();\n \n for (int i = 0; i < _hData->getData().size(); i++) {\n // NOTE: if hData is transposed, then the output minibatch matrix\n // can be a view. No need to allocate new CPU memory here. Might\n // want to look into optimizing that in the future, though it's \n // unlikely to be a big deal.\n if (_hData->isTrans()) {\n miniData.push_back(&(*_hData)[i].sliceCols(startCase, endCase));\n } else {\n miniData.push_back(new Matrix());\n (*_hData)[i].sliceCols(startCase, endCase, *miniData.back());\n }\n }\n CPUData& cpuData = *new CPUData(&miniData);\n return *new CPUData(&miniData);\n}\n\nint DataProvider::getNumMinibatches() {\n assert(_hData != 0);\n assert(_hData->getNumCases() > 0);\n return DIVUP(_hData->getNumCases(), _minibatchSize);\n}\n\nint DataProvider::getMinibatchSize() {\n return _minibatchSize;\n}\n\nint DataProvider::getNumCases() {\n assert(_hData != 0);\n assert(_hData->getNumCases() > 0);\n return _hData->getNumCases();\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/gradreducer.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/util.cuh\"\n#include \"../include/gradreducer.cuh\"\n\nusing namespace std;\n\n/* =====================\n * IGradReducer\n * =====================\n */\nIActGradReducer::IActGradReducer(Layer& parent, map numExpectedMsgs)\n : Thread(true, getDeviceCPUs(parent.getDeviceID())), _parent(&parent), _numExpectedMsgs(numExpectedMsgs) {\n _numExpectedMsgsTotal = 0;\n for (map::const_iterator it = numExpectedMsgs.begin(); it != numExpectedMsgs.end(); ++it) {\n _numExpectedMsgsTotal += it->second;\n }\n// printf(\"%s[%d] expected %d backward msgs\\n\", parent.getName().c_str(), parent.getReplicaID(), _numExpectedMsgsTotal);\n}\n\nIActGradReducer::~IActGradReducer() {\n\n}\n\nvoid* IActGradReducer::run() {\n while (true) {\n reset();\n if (reduce()) {\n break;\n }\n _finishQueue.enqueue(0);\n }\n return NULL;\n}\n\n// Cost layer will have nothing to dequeue, so just return immediately.\nint IActGradReducer::waitForFinish() {\n if (_numExpectedMsgsTotal > 0) {\n int i = _finishQueue.dequeue();\n assert(_finishQueue.getNumElements() == 0);\n return i;\n }\n// printf(\"%s not waiting for finish\\n\", _name.c_str());\n return 0;\n}\n\nIActGradReducer& IActGradReducer::makeGradReducer(Layer& parent, map numExpectedMsgs) {\n int tgtDeviceID = parent.getDeviceID();\n if (numExpectedMsgs.count(tgtDeviceID) == 0) {\n numExpectedMsgs[tgtDeviceID] = 0;\n }\n if (numExpectedMsgs.size() == 8) {\n return *new ParallelActGradReducer(parent, numExpectedMsgs);\n }\n return *new SequentialActGradReducer(parent, numExpectedMsgs);\n}\n\n/* =====================\n * SequentialGradReducer\n * =====================\n */\nSequentialActGradReducer::SequentialActGradReducer(Layer& parent, map numExpectedMsgs)\n : IActGradReducer(parent, numExpectedMsgs) {\n intv deviceIDs;\n int tgtDeviceID = parent.getDeviceID();\n for (map::const_iterator it = numExpectedMsgs.begin(); it != numExpectedMsgs.end(); ++it) {\n if (it->first != tgtDeviceID) {\n deviceIDs.push_back(it->first);\n }\n }\n if (numExpectedMsgs[tgtDeviceID] > 0) {\n deviceIDs.push_back(tgtDeviceID);\n }\n\n sort(deviceIDs.begin(), deviceIDs.end());\n\n int firstDeviceIdx = 0, firstDeviceID = 1 << 16;\n for (int i = 0; i < deviceIDs.size(); ++i) {\n if (deviceIDs[i] >= tgtDeviceID && deviceIDs[i] < firstDeviceID) {\n firstDeviceIdx = i;\n firstDeviceID = deviceIDs[i];\n }\n }\n\n // This is the order in which we process devices.\n for (int i = firstDeviceIdx; _deviceIDs.size() < deviceIDs.size(); i = (i + 1) % deviceIDs.size()) {\n int d = deviceIDs[i];\n _deviceIDs.push_back(d);\n _messageQueues[d] = new Queue();\n }\n //shuffleVector(_deviceIDs, 1, _deviceIDs.size()); \n _broadcaster = new StreamBroadcast();\n\n // Note that we MUST process the tgtDeviceID first because\n // we write to it at every iteration, and the computation\n // thread writes to it too. By processing it first we ensure\n // that there's no race condition.\n assert(numExpectedMsgs[tgtDeviceID] == 0 || _deviceIDs[0] == tgtDeviceID);\n reset();\n}\n\nSequentialActGradReducer::~SequentialActGradReducer() {\n for(map* >::const_iterator it = _messageQueues.begin(); it != _messageQueues.end(); ++it) {\n delete it->second;\n }\n delete _broadcaster;\n}\n\nvoid SequentialActGradReducer::reset() {\n for (map::iterator it = _numReceivedMsgs.begin(); it != _numReceivedMsgs.end(); ++it) {\n _numReceivedMsgs[it->first] = 0;\n }\n}\n\nbool SequentialActGradReducer::reduce() {\n int tgtDeviceID = _parent->getDeviceID();\n for (int didx = 0; didx < _deviceIDs.size(); ) {\n int d = _deviceIDs[didx];\n _numReceivedMsgs[d] += _messageQueues[d]->dequeue();\n if (_numReceivedMsgs[d] == _numExpectedMsgs[d]) {\n if (d != tgtDeviceID) {\n NVMatrix::setDeviceID(tgtDeviceID);\n\n _parent->getActsGrad().resize(_parent->getActsGrad(d));\n map mats;\n mats[d] = &_parent->getActsGrad(d);\n mats[tgtDeviceID] = &_parent->getActsGrad(tgtDeviceID);\n\n _broadcaster->transfer(mats, d, didx > 0, 1);\n }\n didx++;\n assert(_messageQueues[d]->getNumElements() == 0);\n } else if (_numReceivedMsgs[d] >= _numExpectedMsgs[d]) { // exit\n return true;\n }\n }\n return false;\n}\n\nvoid SequentialActGradReducer::enqueueReduction(int deviceID) {\n _messageQueues[deviceID]->enqueue(1);\n}\n\nvoid SequentialActGradReducer::stop() {\n for(map* >::const_iterator it = _messageQueues.begin(); it != _messageQueues.end(); ++it) {\n it->second->enqueue(ACT_GRAD_REDUCER_EXIT);\n }\n join();\n}\n\n/* =====================\n * ParallelActGradReducer\n * =====================\n */\nParallelActGradReducer::ParallelActGradReducer(Layer& parent, map numExpectedMsgs)\n : IActGradReducer(parent, numExpectedMsgs), _numReceivedMsgs(0) {\n _reducer = &(new EightGPUReducer1(parent.getDeviceID()))->construct();\n\n _scaleTarget = numExpectedMsgs.count(parent.getDeviceID()) > 0 && numExpectedMsgs[parent.getDeviceID()] > 0;\n}\n\nbool ParallelActGradReducer::reduce() {\n // TODO: make it so that you can start the reduction before you've received all the messages.\n while(_numReceivedMsgs < _numExpectedMsgsTotal) {\n _numReceivedMsgs += _messageQueue.dequeue();\n }\n if (_numReceivedMsgs > _numExpectedMsgsTotal) {\n return true; // exit\n }\n map mats = _parent->getAllActsGrads();\n _reducer->reduce(mats, 1, _scaleTarget);\n assert(_messageQueue.getNumElements() == 0);\n return false;\n\n}\n\nvoid ParallelActGradReducer::enqueueReduction(int deviceID) {\n _messageQueue.enqueue(1);\n}\n\nvoid ParallelActGradReducer::stop() {\n _messageQueue.enqueue(ACT_GRAD_REDUCER_EXIT);\n join();\n}\n\nvoid ParallelActGradReducer::reset() {\n _numReceivedMsgs = 0;\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/jpeg.cpp", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/jpeg.h\"\n\nusing namespace std;\n\n/* ========================\n * DecoderThread\n * ========================\n */\nDecoderThread::DecoderThread(PyObject* pyList, Matrix& target, int start_img, int end_img, int img_size, int inner_size, bool test, bool multiview)\n: Thread(true), _pyList(pyList), _target(&target), _start_img(start_img), _end_img(end_img),\n _img_size(img_size), _inner_size(inner_size), _test(test), _multiview(multiview),\n _decodeTarget(0), _decodeTargetSize(0) {\n\n _inner_pixels = _inner_size * _inner_size;\n _rseed = time(0);\n}\n\nDecoderThread::~DecoderThread(){\n free(_decodeTarget);\n}\n\nvoid* DecoderThread::run() {\n int numSrcCases = PyList_GET_SIZE(_pyList);\n assert(_target->getNumCols() == _inner_pixels * 3);\n assert(_target->getNumRows() == PyList_GET_SIZE(_pyList) * (_multiview ? 10 : 1));\n\n int width, height;\n\n for (int64 i = _start_img; i < _end_img; ++i) {\n decodeJpeg(i, width, height);\n assert((width == _img_size && height >= _img_size)\n || (height == _img_size && width >= _img_size));\n if (_multiview) {\n for (int flip = 0; flip < 2; ++flip) {\n crop(numSrcCases * (flip * 5 + 0) + i, width, height, flip, 0, 0); // top-left\n crop(numSrcCases * (flip * 5 + 1) + i, width, height, flip, width - _inner_size, 0); // top-right\n crop(numSrcCases * (flip * 5 + 2) + i, width, height, flip, (width - _inner_size) / 2, (height - _inner_size) / 2); // center\n crop(numSrcCases * (flip * 5 + 3) + i, width, height, flip, 0, height - _inner_size); // bottom-left\n crop(numSrcCases * (flip * 5 + 4) + i, width, height, flip, width - _inner_size, height - _inner_size); // bottom-right\n }\n } else {\n crop(i, width, height, !_test && (rand_r(&_rseed) % 2));\n }\n\n }\n return NULL;\n}\n\nvoid DecoderThread::decodeJpeg(int idx, int& width, int& height) {\n PyObject* pySrc = PyList_GET_ITEM(_pyList, idx);\n unsigned char* src = (unsigned char*)PyString_AsString(pySrc);\n size_t src_len = PyString_GET_SIZE(pySrc);\n \n struct jpeg_decompress_struct cinf;\n struct jpeg_error_mgr jerr;\n cinf.err = jpeg_std_error(&jerr);\n jpeg_create_decompress(&cinf);\n jpeg_mem_src(&cinf, src, src_len);\n assert(jpeg_read_header(&cinf, TRUE));\n cinf.out_color_space = JCS_RGB;\n assert(jpeg_start_decompress(&cinf));\n assert(cinf.num_components == 3 || cinf.num_components == 1);\n width = cinf.image_width;\n height = cinf.image_height;\n\n if (_decodeTargetSize < width * height * 3) {\n free(_decodeTarget);\n _decodeTargetSize = width * height * 3 * 3;\n _decodeTarget = (unsigned char*)malloc(_decodeTargetSize);\n }\n \n while (cinf.output_scanline < cinf.output_height) {\n JSAMPROW tmp = &_decodeTarget[width * cinf.out_color_components * cinf.output_scanline];\n assert(jpeg_read_scanlines(&cinf, &tmp, 1) > 0);\n }\n assert(jpeg_finish_decompress(&cinf));\n jpeg_destroy_decompress(&cinf);\n}\n\n/*\n * Uniform in [0,1)\n */\ninline double DecoderThread::randUniform() {\n return double(rand_r(&_rseed)) / (int64(RAND_MAX) + 1);\n}\n\n/*\n * Uniform in [min, max)\n */\ninline double DecoderThread::randUniform(double min, double max) {\n return (max - min) * randUniform() + min;\n}\n\nvoid DecoderThread::crop(int64 i, int64 src_width, int64 src_height, bool flip) {\n crop(i, src_width, src_height, flip, -1, -1);\n}\n\nvoid DecoderThread::crop(int64 i, int64 src_width, int64 src_height, bool flip, int64 crop_start_x, int64 crop_start_y) {\n const int64 border_size_y = src_height - _inner_size;\n const int64 border_size_x = src_width - _inner_size;\n if (crop_start_x < 0) {\n crop_start_x = _test ? (border_size_x / 2) : (rand_r(&_rseed) % (border_size_x + 1));\n }\n if (crop_start_y < 0) {\n crop_start_y = _test ? (border_size_y / 2) : (rand_r(&_rseed) % (border_size_y + 1));\n }\n const int64 src_pixels = src_width * src_height;\n for (int64 c = 0; c < 3; ++c) {\n for (int64 y = crop_start_y; y < crop_start_y + _inner_size; ++y) {\n for (int64 x = crop_start_x; x < crop_start_x + _inner_size; ++x) {\n assert((y >= 0 && y < src_height && x >= 0 && x < src_width));\n _target->getCell(i, c * _inner_pixels + (y - crop_start_y) * _inner_size\n + (flip ? (_inner_size - 1 - x + crop_start_x)\n : (x - crop_start_x)))\n = _decodeTarget[3 * (y * src_width + x) + c];\n }\n }\n }\n}" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/layer.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n#include \"../../cudaconv3/include/cudaconv2.cuh\"\n#include \"../../util/include/matrix.h\"\n#include \"../include/layer_kernels.cuh\"\n#include \"../include/layer.cuh\"\n#include \"../include/data.cuh\"\n#include \"../include/util.cuh\"\n#include \"../include/weights.cuh\"\n\nusing namespace std;\n\n/*\n * =======================\n * Layer\n * =======================\n */\nLayer::Layer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans) :\n _convNetThread(convNetThread), _replicaID(replicaID), _trans(trans) {\n _name = pyDictGetString(paramsDict, \"name\");\n _type = pyDictGetString(paramsDict, \"type\");\n \n _foundGradConsumers = false;\n _gradConsumer = pyDictGetInt(paramsDict, \"gradConsumer\");\n _actsTarget = pyDictGetInt(paramsDict, \"actsTarget\");\n _actsGradTarget = pyDictGetInt(paramsDict, \"actsGradTarget\");\n _numOutputs = pyDictGetInt(paramsDict, \"outputs\");\n _numReplicas = pyDictGetInt(paramsDict, \"numReplicas\");\n _numReplicasPrev = 1;\n _rcvdBInputMsgs = 0;\n\n _actBroadcaster = NULL;\n _gradReducer = NULL;\n _initialized = false;\n}\n\nLayer::~Layer() {\n if (_actBroadcaster != NULL) {\n _actBroadcaster->stop();\n delete _actBroadcaster;\n }\n if (_gradReducer != NULL) {\n _gradReducer->stop();\n delete _gradReducer;\n }\n // For now, gradReducer doesn't have a destructor\n// delete _gradReducer;\n for (std::map::iterator it = _memSrcActs.begin(); it != _memSrcActs.end(); ++it) {\n if (it->second->getMemorySource().truncate(_name)) {\n delete &it->second->getMemorySource();\n }\n }\n for (std::map::iterator it = _memSrcActsGrad.begin(); it != _memSrcActsGrad.end(); ++it) {\n if (it->second->getMemorySource().truncate(_name)) {\n delete &it->second->getMemorySource();\n }\n }\n}\n\ncudaStream_t Layer::getStream() {\n assert(getDeviceID() >= 0);\n return NVMatrix::getDefaultStream(getDeviceID());\n}\n\nvoid Layer::syncStream() {\n NVMatrix::syncStream(getStream());\n}\n\nvoid Layer::fpropNext(PASS_TYPE passType, int passIdx) {\n if (_next.size() > 0) {\n if (getFwdActiveReplicaIdx(passIdx) == 0/*getReplicaIdx()*/) { // 0 turns on pipelining\n if (_nextDeviceIDs.size() > 1 || (_nextDeviceIDs.size() == 1 && _nextDeviceIDs[0] != getDeviceID())) {\n syncStream(); // Make sure I've finished computing before broadcasting\n }\n getActBroadcaster().getMessageQueue().enqueue(new BroadcastMessage(getAllActs(), getDeviceID(), getReplicaIdx(), _broadcastFinishQueue));\n }\n if (getFwdActiveReplicaIdx(passIdx) == getReplicaIdx()) {\n _broadcastFinishQueue.dequeue();\n assert(_broadcastFinishQueue.getNumElements() == 0);\n }\n }\n\n for (int i = 0; i < _next.size(); i++) {\n _next[i]->getConvNetThread().getMessageQueue().enqueue(new FpropMessage(*_next[i], passType, passIdx));\n }\n}\n\nbool Layer::fprop(PASS_TYPE passType, int passIdx) {\n _rcvdFInputMsgs++;\n // I require messages from *all* input replicas because it makes the propagation easier to think about.\n // Without this requirement, when all fprop terminal msgs arrive to ConvNet, the forward propagation\n // might not actually be finished yet.\n if (_rcvdFInputMsgs == getNumExpectedFwdMsgs()) {\n// printf(\"Layer %s[%d] fprop\\n\", _name.c_str(), getReplicaID());\n int ridx = getFwdActiveInputReplicaIdx(passIdx);\n assert(getDeviceID() == NVMatrix::getDeviceID());\n map v;\n if (ridx >= 0) {\n for (int i = 0; i < getNumLayersPrev(); i++) {\n v[i] = &_prev[ridx][i]->getActs(getDeviceID());\n }\n }\n fprop(v, passType, passIdx);\n return true;\n }\n return false;\n}\n\nvoid Layer::fprop(map& v, PASS_TYPE passType, int passIdx) {\n if (getFwdActiveInputReplicaIdx(passIdx) >= 0) {\n assert(v.size() == getNumLayersPrev());\n _inputs.clear();\n _inputs.insert(v.begin(), v.end());\n\n int numCases = _inputs[0]->getLeadingDim();\n for (map::iterator it = _memSrcActs.begin(); it != _memSrcActs.end(); ++it) {\n it->second->getMemory(numCases);\n }\n\n if (numCases > 0) {\n //printf(\"layer %s fprop, numcases: %d\\n\", _name.c_str(), numCases);\n _rcvdFInputMsgs = getNumExpectedFwdMsgs();\n for (map::iterator it = v.begin(); it != v.end(); ++it) {\n it->second->transpose(_trans);\n }\n getActs().transpose(_trans);\n \n fpropCommon(passType);\n\n // First do fprop on the input whose acts matrix I'm sharing, if any\n if (_actsTarget >= 0) {\n fpropActs(_actsTarget, 0, passType, passIdx);\n }\n // Then add the rest of the inputs to that\n for (int i = 0; i < getNumLayersPrev(); i++) {\n if (i != _actsTarget) {\n fpropActs(i, _actsTarget >= 0 || i > 0, passType, passIdx);\n }\n }\n }\n }\n fpropNext(passType, passIdx);\n}\n\nvoid Layer::truncBwdActs() {\n // Only truncate actsGrad if I own it\n if (_actsGradTarget < 0) {\n for (map::iterator it = _memSrcActsGrad.begin(); it != _memSrcActsGrad.end(); ++it) {\n it->second->getMemorySource().truncate(getName());\n }\n }\n if (_actsTarget < 0) {\n for (map::iterator it = _memSrcActs.begin(); it != _memSrcActs.end(); ++it) {\n it->second->getMemorySource().truncate(getName());\n }\n }\n}\n\nint Layer::getNumGradProducersNext() {\n return _numGradProducersNext;\n}\n\nint Layer::getNumExpectedBwdMsgs() {\n return _numGradProducersNext * getNumSiblingReplicas();\n}\n\nint Layer::getNumExpectedFwdMsgs() {\n return getNumLayersPrev() * getNumInputReplicas();\n}\n\nvoid Layer::bprop(PASS_TYPE passType, int passIdx) {\n if (getBwdActiveInputReplicaIdx(passIdx) >= 0 && _rcvdBInputMsgs == getNumExpectedBwdMsgs()) {\n// printf(\"Layer %s[%d] bprop\\n\", _name.c_str(), getReplicaID());\n if (_gradReducer != NULL) {\n _gradReducer->waitForFinish();\n }\n\n // This does sync, but only if it has grad consumers below! so we must sync again before sending bprop terminal messages\n bprop(getActsGrad(), passType, passIdx);\n \n if (_bwdTerminal[passIdx]) {\n syncStream();\n getConvNet().getMessageQueue().enqueue(new Message(BPROP_TERMINAL));\n }\n }\n}\n\nvoid Layer::bpropActsCall(NVMatrix& v, PASS_TYPE passType, int replicaIdx, int inputIdx) {\n Layer& prev = *_prev[replicaIdx][inputIdx];\n if (prev.isGradConsumer() && isGradProducer(prev.getName())) {\n if (v.getLeadingDim() > 0) { // Only do computation if #cases > 0\n bpropActs(v, replicaIdx, inputIdx, prev.getNumComputedActsGrads(getDeviceID()) > 0, passType);\n }\n prev.getNumComputedActsGrads(getDeviceID())++;\n // Synchronize if the previous layer is going to actually do a reduction.\n // If the previous layer is on the same GPU as us and has no next layers\n // on other GPUs then it won't need to do a reduction.\n if (prev.getNextDeviceIDs().size() > 1 || (prev.getNextDeviceIDs().size() == 1 && getDeviceID() != prev.getDeviceID())) {\n syncStream();\n }\n prev.getGradReducer().enqueueReduction(getDeviceID());\n }\n}\n\nvoid Layer::bprop(NVMatrix& v, PASS_TYPE passType, int passIdx) {\n\n v.transpose(_trans);\n assert(getDeviceID() == NVMatrix::getDeviceID());\n int ridx = getBwdActiveInputReplicaIdx(passIdx);\n LayerV& prev = _prev[ridx];\n map > prevByDevice = _prevByDevice[ridx];\n\n for (int i = 0; i < prev.size(); i++) {\n _inputs[i]->transpose(_trans);\n prev[i]->getActsGrad().transpose(_trans);\n }\n getActs().transpose(_trans);\n // NOTE: this should be here (before the bpropActs) because if you have a layer\n // that has a weight matrix AND actsGradTarget >= 0, then the stuff below will overwrite\n // v which is used in bpropCommon. So bpropCommon must come first.\n bpropCommon(v, ridx, passType);\n\n if (isGradProducer()) {\n // First propagate activity gradient to all layers whose activity\n // gradient matrix I'm definitely not sharing.\n for (map >::const_iterator it = prevByDevice.begin(); it != prevByDevice.end(); ++it) {\n const set& deviceLayers = it->second;\n for (set::const_iterator it2 = deviceLayers.begin(); it2 != deviceLayers.end(); ++it2) {\n if (_actsGradTarget != (*it2)->getInputIdx(_name)) {\n bpropActsCall(v, passType, ridx, (*it2)->getInputIdx(_name));\n }\n }\n }\n\n // Then propagate activity gradient to the layer whose activity gradient\n // matrix I'm sharing, if any.\n if (_actsGradTarget >= 0) {\n bpropActsCall(v, passType, ridx, _actsGradTarget);\n }\n }\n\n // Synchronization is necessary because the kernel calls that compute my backward acts\n // execute asynchronously. Therefore I don't want to tell other threads that I've\n // computed bprop activities for them when in fact I've only called a function which\n // will eventually compute them.\n if (_prevDeviceIDs.size() > 1 || (_prevDeviceIDs.size() == 1 && _prevDeviceIDs[0] != getDeviceID())) {\n syncStream();\n }\n\n if (getConvNet().isConserveMemory()) {\n truncBwdActs();\n }\n\n if (isGradProducer()) {\n /*for (int i = 0; i < prev.size(); i++) {\n if (prev[i]->isGradConsumer() && isGradProducer(prev[i]->getName())) {\n prev[i]->getGradReducer().enqueueReduction(getDeviceID());\n }\n }*/\n\n // Send backward messages to *all* replicas.\n // Note that the messages will be dismissed unless the passIdx indicates\n // that the previous layer should do some work.\n for (int r = 0; r < getNumInputReplicas(); r++) {\n for (int i = 0; i < _prev[r].size(); i++) {\n if (_prev[r][i]->isGradConsumer() && isGradProducer(_prev[r][i]->getName())) {\n _prev[r][i]->getConvNetThread().getMessageQueue().enqueue(new BpropMessage(*_prev[r][i], passType, passIdx));\n }\n }\n }\n }\n}\n\nIActGradReducer& Layer::getGradReducer() {\n return *_gradReducer;\n}\n\n// This is called between minibatches\nvoid Layer::reset() {\n _rcvdFInputMsgs = 0;\n _rcvdBInputMsgs = 0;\n for (map::iterator it = _numComputedActsGrads.begin(); it != _numComputedActsGrads.end(); ++it) {\n it->second = 0;\n }\n}\n\n// This is called between microbatches\nvoid Layer::resetPassIdx() {\n _rcvdFInputMsgs = 0;\n if (_rcvdBInputMsgs >= getNumExpectedBwdMsgs()) {\n reset();\n }\n}\n\n/*\n * Returns number of cases in given matrix.\n */\nint Layer::getNumCases(NVMatrix& v) {\n return v.getLeadingDim();\n}\n\nint Layer::incRcvdBInputMsgs() {\n return ++_rcvdBInputMsgs;\n}\n\nstd::string& Layer::getName() {\n return _name;\n}\n\nstd::string& Layer::getType() {\n return _type;\n}\n\nint& Layer::getNumComputedActsGrads(int deviceID) {\n return _numComputedActsGrads[deviceID];\n}\n\nvoid Layer::addNext(Layer& l) {\n _next.push_back(&l);\n _numReplicasNext = l.getNumReplicas();\n if (count(_nextDeviceIDs.begin(), _nextDeviceIDs.end(), l.getDeviceID()) == 0) {\n int pos = rand() % (_nextDeviceIDs.size() + 1);\n _nextDeviceIDs.insert(_nextDeviceIDs.begin() + pos, l.getDeviceID());\n }\n}\n\nvoid Layer::addPrev(Layer& l, int replicaIdx) {\n _prev[replicaIdx].push_back(&l);\n _numReplicasPrev = l.getNumReplicas();\n l.setInputIdx(getName(), _prev[replicaIdx].size() - 1);\n if (l.getDeviceID() >= 0 && count(_prevDeviceIDs.begin(), _prevDeviceIDs.end(), l.getDeviceID()) == 0) {\n int pos = rand() % (_prevDeviceIDs.size() + 1);\n _prevDeviceIDs.insert(_prevDeviceIDs.begin() + pos, l.getDeviceID());\n }\n}\n\nvoid Layer::addReplica(Layer& l) {\n assert(_replicas.count(l.getReplicaID()) == 0);\n _replicas[l.getReplicaID()] = &l;\n}\n\nbool Layer::hasGradProducerNext(std::string& layerName) {\n bool b = _next.size() == 0;\n for (int i = 0; i < _next.size(); i++) {\n b |= _next[i]->hasGradProducerNext(_name);\n }\n return b && isGradProducer(layerName);\n}\n\nbool Layer::postInit() {\n // We choose not to populate _outputs[getDeviceID()] here because we do it instead in fprop().\n // In fprop(), we can populate it from the _inputs vector, which is a bit more general than populating\n // it from _prev->getActs()\n// _outputs = _actsTarget < 0 ? new NVMatrix() : &_prev[_actsTarget]->getActs();\n if (!_initialized) {\n _initialized = true;\n map numGradProducersNext;\n _numGradProducersNext = 0;\n for (int r = 0; r < getNumInputReplicas(); ++r) {\n for (vector::const_iterator it = _prev[r].begin(); it != _prev[r].end(); ++it) {\n (*it)->postInit();\n }\n }\n\n _memSrcActs[getDeviceID()] = _actsTarget < 0 ? &MemorySource::make(_numOutputs, getDeviceID(), getName())\n : &_prev[0][_actsTarget]->getMemorySourceActs(getDeviceID()).clone(_name);\n\n // _actsGradTarget will only be >= 0 when the number of replicas is the same in both layers, so this justifies the use of _prev[0]\n\n _memSrcActsGrad[getDeviceID()] = _actsGradTarget < 0 ? &MemorySource::make(_numOutputs, getDeviceID(), getName())\n : &_prev[0][_actsGradTarget]->getMemorySourceActsGrad(getDeviceID()).clone(_name);\n for (int i = 0; i < _next.size(); ++i) {\n int d = _next[i]->getDeviceID();\n _numComputedActsGrads[d] = 0;\n if (_next[i]->hasGradProducerNext(_name)) {\n if (numGradProducersNext.count(d) == 0) {\n numGradProducersNext[d] = 0;\n }\n numGradProducersNext[d]++;\n _numGradProducersNext++;\n if (_memSrcActsGrad.count(d) == 0) {\n _memSrcActsGrad[d] = &MemorySource::make(_numOutputs, d, getName());\n }\n }\n if (_memSrcActs.count(d) == 0) {\n _memSrcActs[d] = &MemorySource::make(_numOutputs, d, getName());\n }\n }\n\n if (_next.size() == 0) {\n _numReplicasNext = getNumReplicas();\n }\n\n /*\n * Initialize forward broadcaster. First sibling owns it.\n */\n if (getReplicaIdx() == 0 && _convNetThread != NULL) {\n _actBroadcaster = new ActBroadcaster(getNumSiblingReplicas(), getDeviceCPUs(_convNetThread->getDeviceID()));\n _actBroadcaster->start();\n }\n\n /*\n * Initialize backward reducer.\n */\n if (isGradConsumer() && _numGradProducersNext > 0) {\n _gradReducer = &IActGradReducer::makeGradReducer(*this, numGradProducersNext);\n _gradReducer->start();\n }\n\n /*\n * Initialize specially sorted previous array\n */\n for (int r = 0; r < _prev.size(); ++r) {\n for (int i = 0; i < _prev[r].size(); ++i) {\n // Previous devices in reverse order of processing by (sequential) GradReducer\n _prevByDevice[r][getDeviceID() - _prev[r][i]->getDeviceID()\n + 16 * (_prev[r][i]->getDeviceID() > getDeviceID())].insert(_prev[r][i]);\n\n }\n }\n return true;\n }\n return false;\n}\n\nActBroadcaster& Layer::getActBroadcaster() {\n return getReplicaIdx() == 0 ? *_actBroadcaster : _replicas[getReplicaID() - getReplicaIdx()]->getActBroadcaster();\n}\n\n// Does this layer, or some layer below it, need the gradient\n// for parameter updates?\n// Only weight layers should be grad consumers themselves.\nbool Layer::isGradConsumer() {\n if (!_foundGradConsumers && _prev.size() > 0) {\n for (int i = 0; i < _prev[0].size(); i++) {\n _gradConsumer |= _prev[0][i]->isGradConsumer();\n }\n _foundGradConsumers = true;\n }\n return _gradConsumer;\n}\n\n// Does this layer produce gradient for layers below?\nbool Layer::isGradProducer() {\n return true;\n}\n\nbool Layer::isGradProducer(std::string& layerName) {\n return isGradProducer();\n}\n\nmap >& Layer::getPrev() {\n return _prev;\n}\n\nvector& Layer::getNext() {\n return _next;\n}\n\nNVMatrix& Layer::getActs() {\n return getActs(getDeviceID());\n}\n\nNVMatrix& Layer::getActs(int deviceID) {\n assert(_memSrcActs.count(deviceID) > 0);\n return _memSrcActs[deviceID]->getMemory();\n}\n\nNVMatrix& Layer::getActs(int deviceID, int numCases) {\n assert(_memSrcActs.count(deviceID) > 0);\n return _memSrcActs[deviceID]->getMemory(numCases);\n}\n\nNVMatrix& Layer::getActsGrad(int deviceID) {\n assert(_memSrcActsGrad.count(deviceID) > 0);\n return _memSrcActsGrad[deviceID]->getMemory(getActs(deviceID).getLeadingDim());\n}\n\nNVMatrix& Layer::getActsGrad() {\n return getActsGrad(NVMatrix::getDeviceID());\n}\n\nmap Layer::getAllActs() {\n map m;\n for (map::const_iterator it = _memSrcActs.begin(); it != _memSrcActs.end(); ++it) {\n m[it->first] = &it->second->getMemory();\n }\n return m;\n}\n\nmap Layer::getAllActsGrads() {\n map m;\n for (map::const_iterator it = _memSrcActsGrad.begin(); it != _memSrcActsGrad.end(); ++it) {\n m[it->first] = &it->second->getMemory();\n }\n return m;\n}\n\nint Layer::getDeviceID() {\n return _convNetThread == NULL ? -1 : _convNetThread->getDeviceID();\n}\n\nConvNetThread& Layer::getConvNetThread() {\n assert(_convNetThread != NULL);\n return *_convNetThread;\n}\n\nConvNet& Layer::getConvNet() {\n return getConvNetThread().getConvNet();\n}\n\nvoid Layer::setBwdTerminal(int passIdx) {\n _bwdTerminal[passIdx] = true;\n}\n\nint Layer::getReplicaID() {\n return _replicaID;\n}\n\nint Layer::getActivePassPeriod() {\n return getNumReplicas() / getConvNet().getNumReplicasMin();\n}\n\nint Layer::getFwdActiveInputReplicaIdx(int passIdx) {\n const int edge = (passIdx / getActivePassPeriod()) % getNumInputReplicas();\n return passIdx % getActivePassPeriod() == 0 ? edge : -1;\n}\n\nint Layer::getBwdActiveInputReplicaIdx(int passIdx) {\n const int edge = (passIdx / getActivePassPeriod()) % getNumInputReplicas();\n return (passIdx + 1) % getActivePassPeriod() == 0 ? edge : -1;\n}\n\nint Layer::getFwdActiveReplicaIdx(int passIdx) {\n assert(_next.size() > 0);\n return _next[0]->getFwdActiveInputReplicaIdx(passIdx);\n}\n\nint Layer::getNumReplicas() {\n return _replicas.size();\n}\n\nint Layer::getNumSiblingReplicas() {\n return getNumReplicas() / getNumReplicasNext();\n}\n\nint Layer::getNumReplicasPrev() {\n return _numReplicasPrev;\n}\n\nint Layer::getNumReplicasNext() {\n return _numReplicasNext;\n}\n\nint Layer::getNumInputReplicas() {\n return _numReplicasPrev / getNumReplicas();\n}\n\nint Layer::getReplicaIdx() {\n return getReplicaID() % getNumSiblingReplicas();\n}\n\nint Layer::getNumLayersPrev() {\n return _prev.size() > 0 ? _prev[0].size() : 0;\n}\n\nvoid Layer::setMemorySourceActs(int deviceID, MemoryView& mem) {\n assert(_memSrcActs[deviceID]->isParent());\n delete _memSrcActs[deviceID];\n _memSrcActs[deviceID] = &mem;\n if (_actsTarget >= 0 && deviceID == getDeviceID()) {\n assert(getNumInputReplicas() == 1);\n _prev[0][_actsTarget]->setMemorySourceActs(deviceID, mem.clone(_prev[0][_actsTarget]->getName()));\n }\n}\n\nvoid Layer::setMemorySourceActsGrad(int deviceID, MemoryView& mem) {\n assert(_memSrcActsGrad[deviceID]->isParent());\n delete _memSrcActsGrad[deviceID];\n _memSrcActsGrad[deviceID] = &mem;\n if (_actsGradTarget >= 0 && deviceID == getDeviceID()) {\n assert(getNumInputReplicas() == 1);\n _prev[0][_actsGradTarget]->setMemorySourceActsGrad(deviceID, mem.clone(_prev[0][_actsGradTarget]->getName()));\n }\n}\n\nMemoryView& Layer::getMemorySourceActs(int deviceID) {\n return *_memSrcActs[deviceID];\n}\n\nMemoryView& Layer::getMemorySourceActsGrad(int deviceID) {\n return *_memSrcActsGrad[deviceID];\n}\n\nint Layer::getNumOutputs() {\n return _numOutputs;\n}\n\nvoid Layer::setInputIdx(std::string& parentName, int idx) {\n _inputIndices[parentName] = idx;\n}\n\nint Layer::getInputIdx(std::string& parentName) {\n return _inputIndices[parentName];\n}\n\n/*\n * =======================\n * NeuronLayer\n * =======================\n */\nNeuronLayer::NeuronLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n : Layer(convNetThread, paramsDict, replicaID, true) {\n PyObject* neuronDict = PyDict_GetItemString(paramsDict, \"neuron\");\n _neuronType = pyDictGetString(neuronDict, \"type\");\n _neuron = &Neuron::makeNeuron(neuronDict);\n}\n\nNeuronLayer::~NeuronLayer() {\n delete _neuron;\n}\n\nvoid NeuronLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(inpIdx == 0);\n if (!bpropSpecial(v, replicaIdx, inpIdx, scaleTargets, passType)) {\n _neuron->computeInputGrad(v, _prev[replicaIdx][0]->getActsGrad(), scaleTargets > 0);\n }\n}\n\nbool NeuronLayer::bpropSpecial(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n // Special optimization for cross-entropy objective with logistic units.\n // Better to just compute the input gradient in one go to avoid division by small numbers.\n bool doCrossEntGrad = _neuronType == \"logistic\" && _next.size() == 1\n && (_next[0]->getType() == \"cost.bce\" || _next[0]->getType() == \"cost.dce\")\n && _next[0]->getDeviceID() == getDeviceID()\n && _next[0]->getNumReplicas() == getNumReplicas();\n LayerV& prev = _prev[replicaIdx];\n if (doCrossEntGrad) {\n NVMatrix& labels = _next[0]->getPrev()[replicaIdx][0]->getActs(getDeviceID());\n BinomialCrossEntropyCostLayer& cost = *static_cast(_next[0]);\n float gradCoeff = cost.getCoeff();\n labels.transpose(_trans);\n if (cost.getPosWeight() == 1) {\n if (scaleTargets == 0) {\n getActs().add(labels, -gradCoeff, gradCoeff, prev[0]->getActsGrad());\n } else {\n getActs().applyTernary(AddGradientBinaryOperator(NVMatrixBinaryOps::WeightedAdd(-gradCoeff, gradCoeff)),\n labels, prev[0]->getActsGrad(), prev[0]->getActsGrad());\n }\n } else {\n if (scaleTargets == 0) {\n getActs().applyBinary(CrossEntLogisticGradientOperator(gradCoeff, cost.getPosWeight()), labels, prev[0]->getActsGrad());\n } else {\n getActs().applyTernary(AddGradientBinaryOperator(CrossEntLogisticGradientOperator(gradCoeff, cost.getPosWeight())),\n labels, prev[0]->getActsGrad(), prev[0]->getActsGrad());\n }\n }\n }\n return doCrossEntGrad;\n}\n\nvoid NeuronLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n _neuron->activate(*_inputs[0], getActs());\n}\n\nstd::string& NeuronLayer::getNeuronType() {\n return _neuronType;\n}\n\n/*\n * =======================\n * WeightLayer\n * =======================\n *\n * The useGrad parameter here merely expresses a preference by the subclass. It may\n * be overridden by the superclass (WeightLayer) and in that case the subclass must follow its wishes.\n * So when computing gradient updates, the subclass must always first check weights.isUseGrad().\n *\n * Note: biases always useGrad.\n */\nWeightLayer::WeightLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans, bool useGrad) :\n Layer(convNetThread, paramsDict, replicaID, trans) {\n _weightUpdatePassPeriod = pyDictGetInt(paramsDict, \"updatePeriod\");\n\n MatrixV& hWeights = *pyDictGetMatrixV(paramsDict, \"weights\");\n MatrixV& hWeightsInc = *pyDictGetMatrixV(paramsDict, \"weightsInc\");\n Matrix& hBiases = *pyDictGetMatrix(paramsDict, \"biases\");\n Matrix& hBiasesInc = *pyDictGetMatrix(paramsDict, \"biasesInc\");\n PyObject* pyEpsWList = PyDict_GetItemString(paramsDict, \"epsW\");\n PyObject* pyEpsB = PyDict_GetItemString(paramsDict, \"epsB\");\n floatv& momW = *pyDictGetFloatV(paramsDict, \"momW\");\n float momB = pyDictGetFloat(paramsDict, \"momB\");\n floatv& wc = *pyDictGetFloatV(paramsDict, \"wc\");\n floatv& wball = *pyDictGetFloatV(paramsDict, \"wballNormed\");\n\n /*\n * When there are multiple replicas, the present implementation\n * requires that useGrad is true. This is because weights.update()\n * performs a simultaneous write to both replicas' weightsInc matrix,\n * which means that the read should come from somewhere else (i.e. a\n * grads matrix).\n */\n useGrad |= _numReplicas > 1;\n\n // Source layers for shared weights\n stringv& weightSourceLayers = *pyDictGetStringV(paramsDict, \"weightSourceLayers\");\n\n // Weight matrix indices (inside the above source layers) for shared weights\n intv& weightSourceMatrixIndices = *pyDictGetIntV(paramsDict, \"weightSourceMatrixIndices\");\n _weights = new WeightList();\n for (int i = 0; i < weightSourceLayers.size(); i++) {\n std::string& srcLayerName = weightSourceLayers[i];\n int matrixIdx = weightSourceMatrixIndices[i];\n PyObject* pyEpsW = PyList_GetItem(pyEpsWList, i);\n ParameterSchedule& lrs = ParameterSchedule::make(pyEpsW); // Learning rate schedule\n if (srcLayerName == _name) { // Current layer\n _weights->addWeights(*new Weights(_weights->at(matrixIdx), lrs, *this));\n } else if (srcLayerName != \"\") {\n WeightLayer& srcLayer = *static_cast(&convNetThread->getLayer(srcLayerName));\n Weights* srcWeights = &srcLayer.getWeights(matrixIdx);\n _weights->addWeights(*new Weights(*srcWeights, lrs, *this));\n } else {\n _weights->addWeights(*new Weights(*hWeights[i], *hWeightsInc[i], lrs, *this, wc[i], wball[i], momW[i], useGrad));\n }\n }\n _biases = new Weights(hBiases, hBiasesInc, ParameterSchedule::make(pyEpsB), *this, 0, 0, momB, true);\n\n delete &weightSourceLayers;\n delete &weightSourceMatrixIndices;\n delete &hWeights;\n delete &hWeightsInc;\n delete &momW;\n delete &wc;\n delete &wball;\n\n _wStep = 0.02;\n _bStep = 0.005;\n}\n\nWeightLayer::~WeightLayer() {\n delete _weights;\n delete _biases;\n}\n\nbool WeightLayer::postInit() {\n if (Layer::postInit()) {\n _weightUpdatePassPeriod = max(_weightUpdatePassPeriod, getActivePassPeriod());\n assert(_weightUpdatePassPeriod % getActivePassPeriod() == 0);\n return true;\n }\n return false;\n}\n\nvoid WeightLayer::fpropCommon(PASS_TYPE passType) {\n}\n\nvoid WeightLayer::bpropCommon(NVMatrix& v, int replicaIdx, PASS_TYPE passType) {\n if (_biases->getLearningRateSchedule().getBaseValue() > 0) {\n if (v.getNumElements() > 0) {\n bpropBiases(v, passType);\n } else {\n _biases->getGrad().resize(_biases->getW());\n _biases->getGrad().scale(getBIncScale());\n }\n _biases->incNumUpdates();\n }\n for (int i = 0; i < _weights->getSize(); i++) {\n if (_weights->at(i).getLearningRateSchedule().getBaseValue() > 0) {\n if (v.getNumElements() > 0) {\n bpropWeights(v, replicaIdx, i, passType);\n } else {\n _weights->at(i).getGrad().resize(_weights->at(i).getW());\n // This will cause it to forget momentum when shown 0 training cases\n // and _useGrad = false but it's not too important.\n _weights->at(i).getGrad().scale(getIncScale(i, passType));\n }\n // Increment its number of updates\n _weights->at(i).incNumUpdates();\n }\n }\n}\n\nbool WeightLayer::updateWeights() {\n if (getConvNet().getTotalPassesDone() % _weightUpdatePassPeriod == 0) {\n _weights->update(getConvNet().getTrainingProgress());\n _biases->update(getConvNet().getTrainingProgress());\n// constrainWeights();\n return true;\n }\n return false;\n}\n\nbool WeightLayer::constrainWeights() {\n if (getConvNet().getTotalPassesDone() % _weightUpdatePassPeriod == 0) {\n _constrainWeights();\n return true;\n }\n return false;\n}\n\nvoid WeightLayer::_constrainWeights() {\n}\n\nvoid WeightLayer::copyToCPU() {\n _weights->copyToCPU();\n _biases->copyToCPU();\n}\n\nvoid WeightLayer::copyToGPU() {\n _weights->copyToGPU();\n _biases->copyToGPU();\n}\n\nvoid WeightLayer::checkGradient() {\n for (int i = 0; i < _weights->getSize(); i++) {\n getConvNet().checkGradient(_name + \" weights[\" + tostr(i) + \"]\", _wStep, _weights->at(i));\n }\n getConvNet().checkGradient(_name + \" biases\", _bStep, *_biases);\n}\n\nvoid WeightLayer::addReplica(Layer& l) {\n Layer::addReplica(l);\n _weights->addReplica(*static_cast(&l)->_weights);\n _biases->addReplica(*static_cast(&l)->_biases);\n}\n\nWeights& WeightLayer::getWeights(int idx) {\n return _weights->at(idx);\n}\n\nfloat WeightLayer::getGradScale(int inpIdx, PASS_TYPE passType) {\n // weight update period must be multiple of activation period\n // TODO: simply accumulate # of cases seen between weight updates. simpler and more accurate.\n double numCases = _weightUpdatePassPeriod * (getConvNet().getMinibatchSize() / double(getConvNet().getNumPasses()));\n if (_weights->at(inpIdx).isUseGrad()) {\n return passType == PASS_GC ? 1.0f : 1.0f / numCases;\n }\n return passType == PASS_GC ? 1.0f : _weights->at(inpIdx).getEps(getConvNet().getTrainingProgress()) / numCases;\n}\n\nfloat WeightLayer::getIncScale(int inpIdx, PASS_TYPE passType) {\n if (_weights->at(inpIdx).isUseGrad()) {\n return _weights->at(inpIdx).getNumUpdates() > 0;\n }\n return (passType == PASS_GC ? _weights->at(inpIdx).getNumUpdates() > 0\n : (_weights->at(inpIdx).getNumUpdates() == 0 ? _weights->at(inpIdx).getMom() : 1.0f));\n}\n\nNVMatrix& WeightLayer::getGradTarget(int inpIdx) {\n return _weights->at(inpIdx).getGrad();\n}\n\nfloat WeightLayer::getBGradScale(PASS_TYPE passType) {\n int numCases = _weightUpdatePassPeriod * DIVUP(getConvNet().getMinibatchSize(), getConvNet().getNumPasses());\n return passType == PASS_GC ? 1.0f : 1.0f / numCases;\n}\n\nfloat WeightLayer::getBIncScale() {\n return _biases->getNumUpdates() > 0;\n}\n\nNVMatrix& WeightLayer::getWeightMatrix(PASS_TYPE passType, int inpIdx) {\n return _weights->at(inpIdx).getW();\n}\n\nNVMatrix& WeightLayer::getBiasMatrix(PASS_TYPE passType) {\n return _biases->getW();\n}\n\n/*\n * =======================\n * FCLayer\n * =======================\n */\nFCLayer::FCLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool useGrad)\n : WeightLayer(convNetThread, paramsDict, replicaID, true, useGrad) {\n _wStep = 0.01;\n _bStep = 0.01;\n}\n\nvoid FCLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n getActs().addProduct(*_inputs[inpIdx], getWeightMatrix(passType, inpIdx), scaleTargets, 1);\n if (scaleTargets == 0) {\n getActs().addVector(getBiasMatrix(passType), 1, getActs());\n }\n}\n\nvoid FCLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n NVMatrix& weights_T = getWeightMatrix(passType, inpIdx).getTranspose();\n _prev[replicaIdx][inpIdx]->getActsGrad().addProduct(v, weights_T, scaleTargets, 1);\n delete &weights_T;\n}\n\nvoid FCLayer::bpropBiases(NVMatrix& v, PASS_TYPE passType) {\n _biases->getGrad().addSum(v, 0, getBIncScale(), getBGradScale(passType));\n}\n\nvoid FCLayer::bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType) {\n NVMatrix& prevActs_T = _inputs[inpIdx]->getTranspose();\n float scaleGrad = getGradScale(inpIdx, passType);\n float scaleInc = getIncScale(inpIdx, passType);\n getGradTarget(inpIdx).addProduct(prevActs_T, v, scaleInc, scaleGrad);\n delete &prevActs_T;\n}\n\nvoid FCLayer::_constrainWeights() {\n for (int i = 0; i < _weights->getSize(); i++) {\n if (_weights->at(i).getWBall() > 0 && _weights->at(i).isOwner() && _weights->at(i).getLearningRateSchedule().getBaseValue() > 0) {\n// NVMatrix norm2; // Unfortunate extra weight matrix...\n _weights->at(i).getW().sumOfSquares(0, _norm2);\n// norm2.apply(MaxWeightConstraintOperator(_weights->at(i).getWBall()));\n _norm2.apply(HardWeightConstraintOperator(_weights->at(i).getWBall()));\n _weights->at(i).getW().eltwiseMultByVector(_norm2);\n }\n }\n}\n\n/*\n * =======================\n * SplitFCLayer\n * =======================\n */\nSplitFCLayer::SplitFCLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool useGrad)\n : FCLayer(convNetThread, paramsDict, replicaID, useGrad) {\n _numParts = pyDictGetInt(paramsDict, \"parts\");\n}\n\nvoid SplitFCLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n getActs().resize(_inputs[inpIdx]->getNumRows(), _numOutputs, true);\n NVMatrixV& splitInput = _inputs[inpIdx]->splitCols(_numParts);\n NVMatrixV& splitWeights = getWeightMatrix(passType, inpIdx).splitRows(_numParts);\n NVMatrixV& splitTarget = getActs().splitCols(_numParts);\n\n NVMatrix::batchedMatrixMultiply(splitInput, splitWeights, splitTarget, scaleTargets, 1);\n if (scaleTargets == 0) {\n getActs().addVector(getBiasMatrix(passType), 1, getActs());\n }\n\n deleteElements(splitInput, true);\n deleteElements(splitWeights, true);\n deleteElements(splitTarget, true);\n}\n\nvoid SplitFCLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n NVMatrix& weights_T = getWeightMatrix(passType, inpIdx).getTranspose();\n _prev[replicaIdx][inpIdx]->getActsGrad().resize(*_inputs[inpIdx]);\n\n NVMatrixV& splitV = v.splitCols(_numParts);\n NVMatrixV& splitWeights_T = weights_T.splitCols(_numParts);\n NVMatrixV& splitTarget = _prev[replicaIdx][inpIdx]->getActsGrad().splitCols(_numParts);\n\n NVMatrix::batchedMatrixMultiply(splitV, splitWeights_T, splitTarget, scaleTargets, 1);\n\n delete &weights_T;\n deleteElements(splitV, true);\n deleteElements(splitWeights_T, true);\n deleteElements(splitTarget, true);\n}\n\nvoid SplitFCLayer::bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType) {\n NVMatrix& prevActs_T = _inputs[inpIdx]->getTranspose();\n NVMatrixV& splitPrevActs_T = prevActs_T.splitRows(_numParts);\n NVMatrixV& splitV = v.splitCols(_numParts);\n NVMatrixV& splitGradTarget = getGradTarget(inpIdx).splitRows(_numParts);\n\n NVMatrix::batchedMatrixMultiply(splitPrevActs_T, splitV, splitGradTarget, getIncScale(inpIdx, passType), getGradScale(inpIdx, passType));\n\n delete &prevActs_T;\n deleteElements(splitPrevActs_T, true);\n deleteElements(splitV, true);\n deleteElements(splitGradTarget, true);\n}\n\n/*\n * =======================\n * TwoDLayerInterface\n * =======================\n */\nTwoDLayerInterface::TwoDLayerInterface(PyObject* paramsDict) {\n _channels = pyDictGetInt(paramsDict, \"channels\");\n _imgSize = pyDictGetInt(paramsDict, \"imgSize\");\n _imgPixels = _imgSize * _imgSize;\n}\n\n/*\n * =======================\n * LocalLayer\n * =======================\n */\nLocalLayer::LocalLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool useGrad)\n : WeightLayer(convNetThread, paramsDict, replicaID, false, useGrad) {\n _padding = pyDictGetIntV(paramsDict, \"padding\");\n _stride = pyDictGetIntV(paramsDict, \"stride\");\n _filterSize = pyDictGetIntV(paramsDict, \"filterSize\");\n _channels = pyDictGetIntV(paramsDict, \"channels\");\n _imgSize = pyDictGetIntV(paramsDict, \"imgSize\");\n _numFilters = pyDictGetInt(paramsDict, \"filters\");\n _groups = pyDictGetIntV(paramsDict, \"groups\");\n _filterChannels = pyDictGetIntV(paramsDict, \"filterChannels\");\n _filterPixels = pyDictGetIntV(paramsDict, \"filterPixels\");\n _imgPixels = pyDictGetIntV(paramsDict, \"imgPixels\");\n \n _modulesX = pyDictGetInt(paramsDict, \"modulesX\");\n _modules = pyDictGetInt(paramsDict, \"modules\");\n}\n\nLocalLayer::~LocalLayer() {\n delete _padding;\n delete _stride;\n delete _filterSize;\n delete _channels;\n delete _imgSize;\n delete _groups;\n delete _filterChannels;\n delete _filterPixels;\n delete _imgPixels;\n}\n\n/*\n * =======================\n * ConvLayer\n * =======================\n */\nConvLayer::ConvLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n : LocalLayer(convNetThread, paramsDict, replicaID, true) {\n _sumWidth = pyDictGetInt(paramsDict, \"sumWidth\");\n _sharedBiases = pyDictGetInt(paramsDict, \"sharedBiases\");\n _weightContrastNormMin = pyDictGetFloatV(paramsDict, \"wcNormMin\");\n _weightContrastNormMax = pyDictGetFloatV(paramsDict, \"wcNormMax\");\n}\n\nConvLayer::~ConvLayer() {\n delete _weightContrastNormMin;\n delete _weightContrastNormMax;\n}\n\nvoid ConvLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convFilterActs(*_inputs[inpIdx], getWeightMatrix(passType, inpIdx), getActs(), _imgSize->at(inpIdx), _modulesX, _modulesX, _padding->at(inpIdx),\n _stride->at(inpIdx), _channels->at(inpIdx), _groups->at(inpIdx), scaleTargets, 1);\n\n if (scaleTargets == 0) {\n if (_sharedBiases) {\n getActs().reshape(_numFilters, getActs().getNumElements() / _numFilters);\n getActs().addVector(getBiasMatrix(passType));\n getActs().reshape(_numFilters * _modules, getActs().getNumElements() / (_numFilters * _modules));\n } else {\n getActs().addVector(getBiasMatrix(passType));\n }\n }\n}\n\nvoid ConvLayer::bpropBiases(NVMatrix& v, PASS_TYPE passType) {\n float scaleBGrad = getBGradScale(passType);\n float scaleInc = getBIncScale();\n if (_sharedBiases) {\n v.reshape(_numFilters, v.getNumElements() / _numFilters);\n _biases->getGrad().addSum(v, 1, scaleInc, scaleBGrad);\n v.reshape(_numFilters * _modules, v.getNumElements() / (_numFilters * _modules));\n } else {\n _biases->getGrad().addSum(v, 1, scaleInc, scaleBGrad);\n }\n}\n\nvoid ConvLayer::bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType) {\n assert(_weights->at(inpIdx).isUseGrad());\n bool doPartialSum = _sumWidth < _modulesX;\n NVMatrix& tgt = doPartialSum ? _weightGradTmp : _weights->at(inpIdx).getGrad();\n\n float scaleWGrad = getGradScale(inpIdx, passType);\n float scaleTargets = getIncScale(inpIdx, passType) * !doPartialSum;\n\n convWeightActs(*_inputs[inpIdx], v, tgt, _imgSize->at(inpIdx), _modulesX, _modulesX, _filterSize->at(inpIdx), _padding->at(inpIdx),\n _stride->at(inpIdx), _channels->at(inpIdx), _groups->at(inpIdx), _sumWidth, scaleTargets, scaleWGrad);\n\n if (doPartialSum) {\n scaleTargets = _weights->at(inpIdx).getNumUpdates() > 0;\n int outWidth = DIVUP(_modulesX, _sumWidth);\n _weightGradTmp.reshape(outWidth*outWidth, _filterChannels->at(inpIdx) * _filterPixels->at(inpIdx) * _numFilters);\n _weights->at(inpIdx).getGrad().addSum(_weightGradTmp, 0, scaleTargets, 1);\n _weights->at(inpIdx).getGrad().reshape(_filterChannels->at(inpIdx) * _filterPixels->at(inpIdx), _numFilters);\n }\n}\n\nvoid ConvLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n convImgActs(v, getWeightMatrix(passType, inpIdx), _prev[replicaIdx][inpIdx]->getActsGrad(), _imgSize->at(inpIdx), _imgSize->at(inpIdx), _modulesX,\n _padding->at(inpIdx), _stride->at(inpIdx), _channels->at(inpIdx), _groups->at(inpIdx), scaleTargets, 1);\n}\n\nvoid ConvLayer::truncBwdActs() {\n LocalLayer::truncBwdActs();\n _weightGradTmp.truncate();\n}\n\nvoid ConvLayer::_constrainWeights() {\n for (int i = 0; i < _weights->getSize(); i++) {\n if (_weightContrastNormMax->at(i) > 0 && _weights->at(i).isOwner() && _weights->at(i).getLearningRateSchedule().getBaseValue() > 0) {\n float fz = _weights->at(i).getW().getNumRows();\n NVMatrix tmp;\n _weights->at(i).getW().sum(0, tmp);\n _weights->at(i).getW().addVector(tmp, -1.0f / fz, _weights->at(i).getGrad());\n // Now _weights->at(i).getGrad() contains zero-mean filters\n _weights->at(i).getGrad().apply(NVMatrixOps::Square());\n _weights->at(i).getGrad().sum(0, tmp);\n\n tmp.apply(WeightContrastNormOperator(_weightContrastNormMin->at(i), _weightContrastNormMax->at(i), 1.0f / fz));\n // Now tmp has the stdev\n _weights->at(i).getW().eltwiseMultByVector(tmp);\n }\n // It's pretty silly to do both these things but whatever\n if (_weights->at(i).getWBall() > 0 && _weights->at(i).isOwner() && _weights->at(i).getLearningRateSchedule().getBaseValue() > 0) {\n// NVMatrix norm2;\n _weights->at(i).getW().sumOfSquares(0, _norm2);\n\n// norm.apply(MaxWeightConstraintOperator(_weights->at(i).getWBall()));\n _norm2.apply(HardWeightConstraintOperator(_weights->at(i).getWBall()));\n _weights->at(i).getW().eltwiseMultByVector(_norm2);\n }\n }\n}\n\n/*\n * =======================\n * LocalUnsharedLayer\n * =======================\n */\nLocalUnsharedLayer::LocalUnsharedLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n : LocalLayer(convNetThread, paramsDict, replicaID, false) {\n}\n\nvoid LocalUnsharedLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n localFilterActs(*_inputs[inpIdx], getWeightMatrix(passType, inpIdx), getActs(), _imgSize->at(inpIdx), _modulesX, _modulesX, _padding->at(inpIdx),\n _stride->at(inpIdx), _channels->at(inpIdx), _groups->at(inpIdx), scaleTargets, 1);\n if (scaleTargets == 0) {\n getActs().addVector(getBiasMatrix(passType));\n }\n}\n\nvoid LocalUnsharedLayer::bpropBiases(NVMatrix& v, PASS_TYPE passType) {\n _biases->getGrad().addSum(v, 1, getBIncScale(), getBGradScale(passType));\n}\n\nvoid LocalUnsharedLayer::bpropWeights(NVMatrix& v, int replicaIdx, int inpIdx, PASS_TYPE passType) {\n float scaleWGrad = getGradScale(inpIdx, passType);\n float scaleInc = getIncScale(inpIdx, passType);\n localWeightActs(*_inputs[inpIdx], v, getGradTarget(inpIdx), _imgSize->at(inpIdx), _modulesX, _modulesX, _filterSize->at(inpIdx), _padding->at(inpIdx),\n _stride->at(inpIdx), _channels->at(inpIdx), _groups->at(inpIdx), scaleInc, scaleWGrad);\n}\n\nvoid LocalUnsharedLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n localImgActs(v, getWeightMatrix(passType, inpIdx), _prev[replicaIdx][inpIdx]->getActsGrad(),_imgSize->at(inpIdx), _imgSize->at(inpIdx), _modulesX,\n _padding->at(inpIdx), _stride->at(inpIdx), _channels->at(inpIdx), _groups->at(inpIdx), scaleTargets, 1);\n}\n\nvoid LocalUnsharedLayer::_constrainWeights() {\n for (int i = 0; i < _weights->getSize(); i++) {\n if (_weights->at(i).getWBall() > 0 && _weights->at(i).isOwner() && _weights->at(i).getLearningRateSchedule().getBaseValue() > 0) {\n normalizeLocalWeights(*_weights->at(i), _modules, _weights->at(i).getWBall());\n }\n }\n}\n\n/*\n * =======================\n * SoftmaxLayer\n * =======================\n */\nSoftmaxLayer::SoftmaxLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n : Layer(convNetThread, paramsDict, replicaID, true), _doUpperGrad(false) {\n}\n\nvoid SoftmaxLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n NVMatrix& input = *_inputs[0];\n input.max(1, _max);\n input.addVector(_max, -1, getActs());\n getActs().apply(NVMatrixOps::Exp());\n getActs().sum(1, _sum);\n getActs().eltwiseDivideByVector(_sum);\n}\n\nvoid SoftmaxLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(inpIdx == 0);\n LayerV& prev = _prev[replicaIdx];\n if (_doUpperGrad) {\n // Todo: rethink replica IDs or idxes... this here doesn't make a huge amount of sense\n for (int i = 0; i < _next.size(); ++i) {\n if (_next[i]->isGradProducer(getName())) {\n NVMatrix& labels = _next[i]->getPrev()[replicaIdx][0]->getActs(getDeviceID()); // Get cost's labels\n float gradCoeff = dynamic_cast(_next[i])->getCoeff();\n\n computeLogregSoftmaxGrad(labels, getActs(), prev[0]->getActsGrad(), scaleTargets == 1, gradCoeff);\n break;\n }\n }\n\n } else {\n computeSoftmaxGrad(getActs(), v, prev[0]->getActsGrad(), scaleTargets, 1);\n }\n}\n\nvoid SoftmaxLayer::setDoUpperGrad(bool b) {\n _doUpperGrad = b;\n}\n\n/*\n * =======================\n * ConcatenationLayer\n * =======================\n */\nConcatenationLayer::ConcatenationLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n : Layer(convNetThread, paramsDict, replicaID, false) {\n _copyOffsets = pyDictGetIntV(paramsDict, \"copyOffsets\");\n _copyOffsets->push_back(_numOutputs);\n}\n\nConcatenationLayer::~ConcatenationLayer() {\n delete _copyOffsets;\n}\n\nvoid ConcatenationLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n getActs().resize(_numOutputs, _inputs[inpIdx]->getNumCols());\n _inputs[inpIdx]->copy(getActs(), 0, -1, 0, -1, _copyOffsets->at(inpIdx), 0);\n}\n\nvoid ConcatenationLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n NVMatrix& copySrc = v.sliceRows(_copyOffsets->at(inpIdx), _copyOffsets->at(inpIdx + 1)); // view\n _prev[replicaIdx][inpIdx]->getActsGrad().add(copySrc, scaleTargets, 1);\n delete ©Src;\n}\n\n/*\n * =======================\n * PassThroughLayer\n * =======================\n */\nPassThroughLayer::PassThroughLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n : Layer(convNetThread, paramsDict, replicaID, false) {\n}\n\nvoid PassThroughLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n // No-op\n}\n\nvoid PassThroughLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n // No-op\n}\n\nbool PassThroughLayer::postInit() {\n if (Layer::postInit()) {\n assert(getNumInputReplicas() == 1);\n for (int i = 0, offset = 0; i < _prev[0].size(); offset += _prev[0][i]->getNumOutputs(), i++) {\n MemoryView& vActs = _memSrcActs[getDeviceID()]->getMemorySource().addUser(_prev[0][i]->getName(), pair(offset, offset + _prev[0][i]->getNumOutputs()));\n MemoryView& vActsGrad = _memSrcActsGrad[getDeviceID()]->getMemorySource().addUser(_prev[0][i]->getName(), pair(offset, offset + _prev[0][i]->getNumOutputs()));\n _prev[0][i]->setMemorySourceActs(getDeviceID(), vActs);\n _prev[0][i]->setMemorySourceActsGrad(getDeviceID(), vActsGrad);\n }\n return true;\n }\n return false;\n}\n\n\n/*\n * =======================\n * EltwiseSumLayer\n * =======================\n */\nEltwiseSumLayer::EltwiseSumLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false) {\n _coeffs = pyDictGetFloatV(paramsDict, \"coeffs\");\n}\n\nEltwiseSumLayer::~EltwiseSumLayer() {\n delete _coeffs;\n}\n\nvoid EltwiseSumLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n getActs().add(*_inputs[inpIdx], scaleTargets, _coeffs->at(inpIdx));\n}\n\nvoid EltwiseSumLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n _prev[replicaIdx][inpIdx]->getActsGrad().add(v, scaleTargets, _coeffs->at(inpIdx));\n}\n\n/*\n * =======================\n * EltwiseMaxLayer\n * =======================\n */\nEltwiseMaxLayer::EltwiseMaxLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false) {\n}\n\nvoid EltwiseMaxLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n if (inpIdx == 1) { // First input, do nothing\n _inputs[inpIdx]->applyBinary(NVMatrixAggs::Max(), *_inputs[0], getActs());\n } else if (inpIdx > 1) {\n getActs().applyBinary(NVMatrixAggs::Max(), *_inputs[inpIdx]);\n }\n}\n\nvoid EltwiseMaxLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n computeEltwiseMaxGrad(v, *_inputs[inpIdx], getActs(), _prev[replicaIdx][inpIdx]->getActsGrad(), scaleTargets != 0);\n}\n\n\n/*\n * =======================\n * DropoutLayer\n * =======================\n *\n * TODO: optimize away the case when using dopout over relus. Don't need the keepmask.\n */\nDropoutLayer::DropoutLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false) {\n _enable = pyDictGetInt(paramsDict, \"enable\");\n _keep = pyDictGetFloat(paramsDict, \"keep\");\n}\n\nvoid DropoutLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n if (_enable && passType == PASS_TRAIN) {\n _keepMask.resize(*_inputs[inpIdx]);\n _keepMask.randomizeUniform();\n _keepMask.apply(DropoutSmallerThanOperator(_keep));\n _inputs[inpIdx]->eltwiseMult(_keepMask, getActs());\n } else {\n _inputs[inpIdx]->copy(getActs());\n }\n}\n\nvoid DropoutLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n LayerV& prev = _prev[replicaIdx];\n if (_enable && passType == PASS_TRAIN) {\n if (scaleTargets != 0) {\n v.applyTernary(AddGradientBinaryOperator(NVMatrixBinaryOps::Multiply()),\n _keepMask, prev[inpIdx]->getActsGrad(), prev[inpIdx]->getActsGrad());\n } else {\n v.eltwiseMult(_keepMask, prev[inpIdx]->getActsGrad());\n }\n } else {\n prev[inpIdx]->getActsGrad().add(v, scaleTargets, 1);\n }\n}\n\nvoid DropoutLayer::truncBwdActs() {\n Layer::truncBwdActs();\n _keepMask.truncate();\n}\n\n\n/*\n * =======================\n * Dropout2Layer\n * =======================\n *\n * TODO: optimize away the case when using dopout over relus. Don't need the keepmask.\n */\nDropout2Layer::Dropout2Layer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : DropoutLayer(convNetThread, paramsDict, replicaID) {\n}\n\nvoid Dropout2Layer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n if (_enable && passType == PASS_TRAIN) {\n _keepMask.resize(*_inputs[inpIdx]);\n _keepMask.randomizeUniform();\n _keepMask.smallerThanScalar(_keep);\n _inputs[inpIdx]->eltwiseMult(_keepMask, getActs());\n } else {\n _inputs[inpIdx]->scale(_keep, getActs());\n }\n}\n\nvoid Dropout2Layer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n LayerV& prev = _prev[replicaIdx];\n if (_enable && passType == PASS_TRAIN) {\n if (scaleTargets != 0) {\n v.applyTernary(AddGradientBinaryOperator(NVMatrixBinaryOps::Multiply()),\n _keepMask, prev[inpIdx]->getActsGrad(), prev[inpIdx]->getActsGrad());\n } else {\n v.eltwiseMult(_keepMask, prev[inpIdx]->getActsGrad());\n }\n } else {\n if (scaleTargets != 0) {\n v.applyBinary(AddGradientOperator(NVMatrixOps::MultByScalar(_keep)),\n prev[inpIdx]->getActsGrad(), prev[inpIdx]->getActsGrad());\n } else {\n v.scale(_keep, prev[inpIdx]->getActsGrad());\n }\n }\n}\n\n/*\n * =======================\n * DataLayer\n * =======================\n */\nDataLayer::DataLayer(ConvNet* convNet, PyObject* paramsDict, int replicaID) : Layer(NULL, paramsDict, replicaID, false) {\n _dataIdx = pyDictGetInt(paramsDict, \"dataIdx\");\n _start = pyDictGetInt(paramsDict, \"start\");\n _end = pyDictGetInt(paramsDict, \"end\");\n _useBuffer = false;\n _outstandingCopyRequest = false;\n _convNet = convNet;\n}\n\nDataLayer::~DataLayer() {\n for (map::const_iterator it = _copyStreams.begin(); it != _copyStreams.end(); ++it) {\n checkCudaErrors(cudaStreamDestroy(it->second));\n }\n for (std::map::iterator it = _memSrcActs2.begin(); it != _memSrcActs2.end(); ++it) {\n if (it->second->getMemorySource().truncate(_name)) {\n delete &it->second->getMemorySource();\n }\n }\n _copier->stop();\n delete _copier;\n}\n\nvoid DataLayer::fprop(PASS_TYPE passType, int passIdx, bool fromBuffer) {\n waitForCopyFinish();\n if (fromBuffer && getFwdActiveInputReplicaIdx(passIdx) >= 0) {\n _useBuffer = !_useBuffer;\n }\n\n for (int i = 0; i < _next.size(); i++) {\n _next[i]->getConvNetThread().getMessageQueue().enqueue(new FpropMessage(*_next[i], passType, passIdx));\n }\n}\n\nvoid DataLayer::waitForCopyFinish() {\n if (_outstandingCopyRequest) {\n _copyFinishQueue.dequeue();\n assert(_copyFinishQueue.getNumElements() == 0);\n _outstandingCopyRequest = false;\n }\n}\n\ncudaStream_t DataLayer::getCopyStream(int deviceID) {\n if (_copyStreams.count(deviceID) == 0) {\n NVMatrix::setDeviceID(deviceID);\n checkCudaErrors(cudaStreamCreateWithFlags(&_copyStreams[deviceID], cudaStreamNonBlocking));\n }\n return _copyStreams[deviceID];\n}\n\nvoid DataLayer::copyData(CPUData& data, bool other, int passIdx) {\n assert(!_outstandingCopyRequest);\n assert(_copyFinishQueue.getNumElements() == 0);\n _copier->getQueue().enqueue(new DataCopyMessage(data, other, passIdx));\n _outstandingCopyRequest = true;\n}\n\nint DataLayer::getNumInputReplicas() {\n return _convNet->getNumReplicasMax() / getNumReplicas();\n}\n\nvoid DataLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n \n}\n\nNVMatrix& DataLayer::getActs(int deviceID) {\n return getActs(deviceID, false, -1);\n}\n\nNVMatrix& DataLayer::getActs(int deviceID, bool other, int numCases) {\n// printf(\"%s[%d] getActs(%d, %d, %d)\\n\", _name.c_str(), getReplicaID(), deviceID, other, numCases);\n assert(_memSrcActs.count(deviceID) > 0);\n assert(_memSrcActs2.count(deviceID) > 0);\n return (_useBuffer != other ? _memSrcActs2[deviceID]->getMemory(numCases) : _memSrcActs[deviceID]->getMemory(numCases));\n}\n\nConvNet& DataLayer::getConvNet() {\n return *_convNet;\n}\n\nbool DataLayer::postInit() {\n if (Layer::postInit()) {\n for (int i = 0; i < _next.size(); ++i) {\n int d = _next[i]->getDeviceID();\n if (_memSrcActs2.count(d) == 0) {\n _memSrcActs2[d] = &MemorySource::make(_numOutputs, d, getName());\n }\n }\n intv cpus = getDeviceCPUs(_next[0]->getDeviceID());\n _copier = new DataCopyThread(*this, cpus);\n _copier->start();\n return true;\n }\n return false;\n}\n\nbool DataLayer::isGradProducer() {\n return false;\n}\n\n/*\n * =======================\n * DataCopyThread\n * =======================\n */\nDataCopyThread::DataCopyThread(DataLayer& parent, intv& cpus) : _parent(&parent), _sleepUsec(0), Thread(true, cpus) {\n}\n\nQueue& DataCopyThread::getQueue() {\n return _queue;\n}\n\nvoid DataCopyThread::stop() {\n getQueue().enqueue(new DataCopyExitMessage());\n join();\n}\n\nvoid* DataCopyThread::run() {\n NVMatrix::setDeviceID(*_parent->getNextDeviceIDs().begin());\n bool exit = false;\n while(!exit) {\n DataCopyMessage& msg = *_queue.dequeue();\n exit = msg.getType() == DataCopyMessage::EXIT;\n if (!exit) {\n CPUData& data = msg.getData();\n int passIdx = msg.getPassIdx();\n bool other = msg.isOther();\n\n Matrix& dataMatrix = data.getData(_parent->getDataIdx());\n // How many times is this layer going to process microbatches from this minibatch?\n assert(_parent->getNumReplicasNext() == _parent->getNumReplicas());\n int microIdx = _parent->getFwdActiveInputReplicaIdx(passIdx);\n\n if (microIdx >= 0) {\n if (_requestTimer.isStarted()) {\n double requestIntervalMsec = _requestTimer.stop();\n // Sleep for up to 1/20th the average request interval\n _sleepUsec = int(round(0.95 * _sleepUsec + 0.05 * (_parent->getReplicaID() / double(_parent->getNumReplicas())) * requestIntervalMsec * 1000.0 / 20.0));\n }\n _requestTimer.start();\n if (other) {\n // Sleeping a bit is helpful because in typical nets, copying input data\n // as soon as it's available will produce contention with other communications\n // that are happening at the time. This is very much a hack, so in the future\n // it might be good to replace it with something smarter which schedules access\n // to communication links.\n usleep(_sleepUsec);\n }\n microIdx += _parent->getReplicaID() * _parent->getNumInputReplicas();\n // Safer to divup because this way you won't get a minibatch size of 0\n int microbatchSize = DIVUP(data.getNumCases(), _parent->getConvNet().getNumReplicasMax());\n int microStart = microIdx * microbatchSize;\n int microEnd = min(data.getNumCases(), (microIdx + 1) * microbatchSize);\n // Check that this replica has some data. This can be false when, for example,\n // there are only 7 examples in the minibatch but 8 replicas.\n if (microStart < microEnd) {\n assert(dataMatrix.isView() == dataMatrix.isTrans());\n int pipe = _parent->getConvNet().getDataCopyPD().getPipe(_parent->getReplicaID()/2);\n if (dataMatrix.isTrans()) {\n Matrix& replicaDataMatrix = dataMatrix.sliceCols(microStart, microEnd);\n // In this case, dataMatrix is a view on memory allocated by Python.\n //_hostMemFwd.copyFromHost(replicaDataMatrix, true);\n _hostMemFwd.resize(replicaDataMatrix.getNumRows(), replicaDataMatrix.getNumCols(), true);\n memcpy(_hostMemFwd.getDevData(), replicaDataMatrix.getData(), replicaDataMatrix.getNumDataBytes());\n delete &replicaDataMatrix; // view\n NVMatrix& hostMemFwdSlice = _hostMemFwd.sliceRows(_parent->getStart(), _parent->getEnd());\n for (intv::iterator it = _parent->getNextDeviceIDs().begin(); it != _parent->getNextDeviceIDs().end(); ++it) {\n int deviceID = *it;\n // Copy my output to this guy's GPU\n NVMatrix::setDeviceID(deviceID);\n // Note to self: this is the path that gets executed in practice\n // in my models. It does a transpose & copy simultaneously.\n hostMemFwdSlice.flipTrans(_parent->getActs(deviceID, other, microEnd - microStart), _parent->getCopyStream(deviceID));\n }\n delete &hostMemFwdSlice;\n } else {\n // Hacky way to copy a slice to _hostMemFwd\n _hostMemFwd.resize(dataMatrix.getNumRows(), microEnd - microStart);\n Matrix tmp(_hostMemFwd.getDevData(), _hostMemFwd.getNumRows(), _hostMemFwd.getNumCols(), _hostMemFwd.isTrans());\n dataMatrix.sliceCols(microStart, microEnd, tmp);\n NVMatrix& hostMemFwdSlice = _hostMemFwd.sliceRows(_parent->getStart(), _parent->getEnd());\n for (intv::iterator it = _parent->getNextDeviceIDs().begin(); it != _parent->getNextDeviceIDs().end(); ++it) {\n int deviceID = *it;\n // Copy my output to this guy's GPU\n NVMatrix::setDeviceID(deviceID);\n hostMemFwdSlice.copy(_parent->getActs(deviceID, other, microEnd - microStart), _parent->getCopyStream(deviceID));\n }\n delete &hostMemFwdSlice;\n }\n\n for (intv::iterator it = _parent->getNextDeviceIDs().begin(); it != _parent->getNextDeviceIDs().end(); ++it) {\n int deviceID = *it;\n NVMatrix::setDeviceID(deviceID);\n NVMatrix::syncStream(_parent->getCopyStream(deviceID));\n }\n _parent->getConvNet().getDataCopyPD().freePipe(pipe);\n } else {\n for (intv::iterator it = _parent->getNextDeviceIDs().begin(); it != _parent->getNextDeviceIDs().end(); ++it) {\n int deviceID = *it;\n _parent->getActs(deviceID, other, 0);\n }\n }\n }\n _parent->getCopyFinishQueue().enqueue(1);\n }\n delete &msg;\n }\n return NULL;\n}\n\n/*\n * =====================\n * PoolLayer\n * =====================\n */\nPoolLayer::PoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans)\n : Layer(convNetThread, paramsDict, replicaID, trans), TwoDLayerInterface(paramsDict) {\n _sizeX = pyDictGetInt(paramsDict, \"sizeX\");\n _start = pyDictGetInt(paramsDict, \"start\");\n _stride = pyDictGetInt(paramsDict, \"stride\");\n _outputsX = pyDictGetInt(paramsDict, \"outputsX\");\n _pool = pyDictGetString(paramsDict, \"pool\");\n}\n\nPoolLayer& PoolLayer::make(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) {\n std::string _pool = pyDictGetString(paramsDict, \"pool\");\n if (_pool == \"max\") {\n return *new MaxPoolLayer(convNetThread, paramsDict, replicaID, false);\n } else if(_pool == \"maxabs\") {\n return *new MaxPoolLayer(convNetThread, paramsDict, replicaID, true);\n } else if(_pool == \"avg\") {\n return *new AvgPoolLayer(convNetThread, paramsDict, replicaID);\n }\n throw std::string(\"Unknown pooling layer type \") + _pool;\n}\n\n/*\n * =====================\n * AvgPoolLayer\n * =====================\n */\nAvgPoolLayer::AvgPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : PoolLayer(convNetThread, paramsDict, replicaID, false) {\n _sum = pyDictGetInt(paramsDict, \"sum\");\n}\n\nvoid AvgPoolLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n if (_sum) {\n convLocalPool(*_inputs[0], getActs(), _channels, _sizeX, _start, _stride, _outputsX, AvgPooler());\n } else {\n convLocalPool(*_inputs[0], getActs(), _channels, _sizeX, _start, _stride, _outputsX, AvgPooler());\n }\n}\n\nvoid AvgPoolLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n convLocalAvgUndo(v, _prev[replicaIdx][0]->getActsGrad(), _sizeX, _start, _stride, _outputsX, _imgSize, _sum, scaleTargets, 1);\n}\n\n/*\n * =====================\n * MaxPoolLayer\n * =====================\n */\nMaxPoolLayer::MaxPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool abs) : PoolLayer(convNetThread, paramsDict, replicaID, false), _abs(abs) {\n}\n\nvoid MaxPoolLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n if (_abs) {\n convLocalPool(*_inputs[0], getActs(), _channels, _sizeX, _start, _stride, _outputsX, MaxAbsPooler());\n } else {\n convLocalPool(*_inputs[0], getActs(), _channels, _sizeX, _start, _stride, _outputsX, MaxPooler());\n }\n}\n\nvoid MaxPoolLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(inpIdx == 0);\n convLocalMaxUndo(*_inputs[0], v, getActs(), _prev[replicaIdx][inpIdx]->getActsGrad(), _sizeX, _start, _stride, _outputsX, scaleTargets, 1);\n}\n\n/*\n * =====================\n * CrossMapPoolLayer\n * =====================\n */\nCrossMapPoolLayer::CrossMapPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans)\n : Layer(convNetThread, paramsDict, replicaID, trans), TwoDLayerInterface(paramsDict) {\n _size = pyDictGetInt(paramsDict, \"size\");\n _start = pyDictGetInt(paramsDict, \"start\");\n _stride = pyDictGetInt(paramsDict, \"stride\");\n _outputs = pyDictGetInt(paramsDict, \"outputChannels\");\n _pool = pyDictGetString(paramsDict, \"pool\");\n}\n\nCrossMapPoolLayer& CrossMapPoolLayer::make(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) {\n std::string _pool = pyDictGetString(paramsDict, \"pool\");\n if (_pool == \"max\") {\n return *new CrossMapMaxPoolLayer(convNetThread, paramsDict, replicaID);\n }\n throw std::string(\"Unknown pooling layer type \") + _pool;\n}\n\n/*\n * =====================\n * CrossMapMaxPoolLayer\n * =====================\n */\nCrossMapMaxPoolLayer::CrossMapMaxPoolLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : CrossMapPoolLayer(convNetThread, paramsDict, replicaID, false) {\n}\n\nvoid CrossMapMaxPoolLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convPoolCrossMap(*_inputs[0], getActs(), _start, _size, _outputs, _stride, _imgSize, MaxPooler());\n}\n\nvoid CrossMapMaxPoolLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(inpIdx == 0);\n convCrossMapMaxPoolUndo(*_inputs[0], v, getActs(), _prev[replicaIdx][0]->getActsGrad(), _imgSize, _start, _size, _stride, scaleTargets, 1);\n}\n\n/*\n * =====================\n * RandomScaleLayer\n * =====================\n */\nRandomScaleLayer::RandomScaleLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false), TwoDLayerInterface(paramsDict) {\n _maxScale = pyDictGetFloat(paramsDict, \"maxScale\");\n _tgtSize = pyDictGetInt(paramsDict, \"tgtSize\");\n // The smallest size the image could be after rescaling\n _minScaledSize = _imgSize / _maxScale;\n \n // The number of discrete scales we're considering\n int numScales = _imgSize - _minScaledSize + 1;\n \n // The total number of squares of size _tgtSize that we can extract\n // from all these scales\n double numCrops = numScales * (numScales + 1) * (2 * numScales + 1) / 6;\n \n // For each scale, record the fraction of the squares that it has.\n // This will be the probability of sampling this scale.\n _scaleProbs.push_back(1.0 / numCrops);\n for (int s = 1; s < numScales; ++s) {\n _scaleProbs.push_back(_scaleProbs[s-1] + (s + 1) * (s + 1) / numCrops);\n }\n}\n\nvoid RandomScaleLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n if (IS_TRAIN(passType)) {\n // _maxScale is in the range [1, 2)\n float r = randf;\n int rescaledSize = _tgtSize;\n float scaleFactor = _maxScale;\n // Find which scale we have sampled\n for (int s = 0; s < _scaleProbs.size(); ++s) {\n if (r <= _scaleProbs[s]) {\n rescaledSize += s;\n float scaleFactorEnd = _imgSize / float(rescaledSize);\n float scaleFactorStart = max(1.0, _imgSize / (1.0 + rescaledSize));\n scaleFactor = scaleFactorStart + randf * (scaleFactorEnd - scaleFactorStart);\n break;\n }\n }\n assert(rescaledSize >= _tgtSize);\n int maxStart = rescaledSize - _tgtSize;\n int startY = rand() % (1 + maxStart), startX = rand() % (1 + maxStart);\n if (rescaledSize == _imgSize) {\n convCrop(*_inputs[0], getActs(), rescaledSize, _tgtSize, startY, startX);\n } else {\n convResizeBilinear(*_inputs[0], _rescaledActs, _imgSize, rescaledSize, scaleFactor);\n convCrop(_rescaledActs, getActs(), rescaledSize, _tgtSize, startY, startX);\n }\n _rescaledActs.truncate(); // this'll have a different size each time so may as well truncate it.\n } else if (IS_MULTIVIEW_TEST(passType)) { // for now...\n _inputs[0]->copy(getActs());\n } else if (IS_TEST(passType)) { // Test on center patch\n convResizeBilinear(*_inputs[0], getActs(), _imgSize, _tgtSize, _maxScale);\n }\n}\n\nvoid RandomScaleLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(false);\n}\n\n/*\n * =====================\n * CropLayer\n * =====================\n */\nCropLayer::CropLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false), TwoDLayerInterface(paramsDict) {\n _startX = pyDictGetInt(paramsDict, \"startX\");\n _startY = pyDictGetInt(paramsDict, \"startY\");\n _tgtSize = pyDictGetInt(paramsDict, \"sizeX\");\n}\n\nvoid CropLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convCrop(*_inputs[0], getActs(), _imgSize, _tgtSize, _startY, _startX);\n}\n\nvoid CropLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(false);\n}\n\n/*\n * =====================\n * NailbedLayer\n * =====================\n */\nNailbedLayer::NailbedLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false), TwoDLayerInterface(paramsDict) {\n _start = pyDictGetInt(paramsDict, \"start\");\n _stride = pyDictGetInt(paramsDict, \"stride\");\n _outputsX = pyDictGetInt(paramsDict, \"outputsX\");\n}\n\nvoid NailbedLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convBedOfNails(*_inputs[0], getActs(), _channels, _imgSize, _start, _stride, 0, 1);\n}\n\nvoid NailbedLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n convBedOfNailsUndo(v, _prev[replicaIdx][0]->getActsGrad(), _channels, _imgSize, _start, _stride, scaleTargets, 1);\n}\n\n/*\n * =====================\n * GaussianBlurLayer\n * =====================\n */\nGaussianBlurLayer::GaussianBlurLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false), TwoDLayerInterface(paramsDict) {\n _hFilter = pyDictGetMatrix(paramsDict, \"filter\");\n}\n\nGaussianBlurLayer::~GaussianBlurLayer() {\n delete _hFilter;\n}\n\nvoid GaussianBlurLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convGaussianBlur(*_inputs[0], _filter, getActs(), true, _channels, 0, 1);\n convGaussianBlur(getActs(), _filter, getActs(), false, _channels, 0, 1);\n}\n\nvoid GaussianBlurLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n NVMatrix& tgt = _prev[replicaIdx][0]->getNumComputedActsGrads(getDeviceID()) > 0 ? _actGradsTmp : _prev[replicaIdx][0]->getActsGrad();\n convGaussianBlur(v, _filter, tgt, true, _channels, 0, 1);\n convGaussianBlur(tgt, _filter, _prev[replicaIdx][0]->getActsGrad(), false, _channels, scaleTargets, 1);\n}\n\nvoid GaussianBlurLayer::copyToGPU() {\n _filter.copyFromHost(*_hFilter, true);\n}\n\n /*\n * =====================\n * HorizontalReflectionLayer\n * =====================\n */\nHorizontalReflectionLayer::HorizontalReflectionLayer(ConvNetThread* convNet, PyObject* paramsDict, int replicaID) : Layer(convNet, paramsDict, replicaID, false), TwoDLayerInterface(paramsDict) {\n assert(_channels >= 1 && _channels <= 3);\n}\n\nvoid HorizontalReflectionLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convReflectHorizontal(*_inputs[0], getActs(), _imgSize);\n}\n\nvoid HorizontalReflectionLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n convReflectHorizontal(v, _prev[replicaIdx][0]->getActsGrad(), _imgSize);\n}\n\n/*\n * =====================\n * ResizeLayer\n * =====================\n */\nResizeLayer::ResizeLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false), TwoDLayerInterface(paramsDict) {\n _tgtSize = pyDictGetInt(paramsDict, \"tgtSize\");\n _scale = pyDictGetFloat(paramsDict, \"scale\");\n}\n\nvoid ResizeLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convResizeBilinear(*_inputs[0], getActs(), _imgSize, _tgtSize, _scale);\n}\n\n// Can't do this\nvoid ResizeLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(false);\n}\n\n/*\n * =====================\n * RGBToYUVLayer\n * =====================\n */\nRGBToYUVLayer::RGBToYUVLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false) {\n}\n\nvoid RGBToYUVLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convRGBToYUV(*_inputs[0], getActs());\n}\n\n// Can't do this\nvoid RGBToYUVLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(false);\n}\n\n/*\n * =====================\n * RGBToLABLayer\n * =====================\n */\nRGBToLABLayer::RGBToLABLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : Layer(convNetThread, paramsDict, replicaID, false) {\n _center = pyDictGetInt(paramsDict, \"center\");\n}\n\nvoid RGBToLABLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convRGBToLAB(*_inputs[0], getActs(), _center);\n}\n\n// Can't do this\nvoid RGBToLABLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(false);\n}\n\n/*\n * =====================\n * ResponseNormLayer\n * =====================\n */\nResponseNormLayer::ResponseNormLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n: Layer(convNetThread, paramsDict, replicaID, false), TwoDLayerInterface(paramsDict) {\n _size = pyDictGetInt(paramsDict, \"size\");\n _scale = pyDictGetFloat(paramsDict, \"scale\");\n _pow = pyDictGetFloat(paramsDict, \"pow\");\n _minDiv = pyDictGetFloat(paramsDict, \"minDiv\");\n}\n\nvoid ResponseNormLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n convResponseNorm(*_inputs[0], _denoms, getActs(), _channels, _size, _scale, _pow, _minDiv);\n}\n\nvoid ResponseNormLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n convResponseNormUndo(v, _denoms, *_inputs[0], getActs(), _prev[replicaIdx][0]->getActsGrad(), _channels, _size, _scale, _pow, scaleTargets, 1);\n}\n\nvoid ResponseNormLayer::truncBwdActs() {\n Layer::truncBwdActs();\n _denoms.truncate();\n}\n\n/*\n * =====================\n * CrossMapResponseNormLayer\n * =====================\n */\nCrossMapResponseNormLayer::CrossMapResponseNormLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n: ResponseNormLayer(convNetThread, paramsDict, replicaID) {\n _blocked = pyDictGetInt(paramsDict, \"blocked\");\n}\n\nvoid CrossMapResponseNormLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n assert(inpIdx == 0);\n convResponseNormCrossMap(*_inputs[0], getActs(), _channels, _size, _scale, _pow, _minDiv, _blocked);\n}\n\nvoid CrossMapResponseNormLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n convResponseNormCrossMapUndo(v, *_inputs[0], getActs(), _prev[replicaIdx][0]->getActsGrad(), _channels, _size, _scale, _pow, _minDiv, _blocked, scaleTargets, 1);\n}\n\n/*\n * =====================\n * ContrastNormLayer\n * =====================\n */\nContrastNormLayer::ContrastNormLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : ResponseNormLayer(convNetThread, paramsDict, replicaID) {\n}\n\nvoid ContrastNormLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n NVMatrix& images = *_inputs[0];\n convLocalPool(images, _meanDiffs, _channels, _size, -_size/2, 1, _imgSize, AvgPooler());\n _meanDiffs.add(images, -1, 1);\n convContrastNorm(images, _meanDiffs, _denoms, getActs(), _channels, _size, _scale, _pow, _minDiv);\n}\n\nvoid ContrastNormLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n convContrastNormUndo(v, _denoms, _meanDiffs, getActs(), _prev[replicaIdx][inpIdx]->getActsGrad(), _channels, _size, _scale, _pow, scaleTargets, 1);\n}\n\nvoid ContrastNormLayer::truncBwdActs() {\n ResponseNormLayer::truncBwdActs();\n _meanDiffs.truncate();\n}\n\n/*\n * =====================\n * CostLayer\n * =====================\n */\nCostLayer::CostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID, bool trans)\n : Layer(convNetThread, paramsDict, replicaID, trans) {\n _coeff = pyDictGetFloat(paramsDict, \"coeff\");\n _numCases = 0;\n _aggregated = pyDictGetInt(paramsDict, \"aggregated\") != 0;\n}\n\nfloat CostLayer::getCoeff() {\n return _coeff;\n}\n\nvoid CostLayer::bprop(NVMatrix& v, PASS_TYPE passType, int passIdx) {\n if (_coeff != 0) {\n Layer::bprop(v, passType, passIdx);\n }\n}\n\nbool CostLayer::fprop(PASS_TYPE passType, int passIdx) {\n if (Layer::fprop(passType, passIdx)) {\n syncStream();\n getConvNet().getMessageQueue().enqueue(new Message(FPROP_TERMINAL));\n return true;\n }\n return false;\n}\n\nvoid CostLayer::fpropCommon(PASS_TYPE passType) {\n _numCases = Layer::getNumCases(*_inputs[0]);\n}\n\nint CostLayer::getNumCases() {\n return _numCases;\n}\n\nbool CostLayer::isGradProducer() {\n return _coeff != 0;\n}\n\ndoublev& CostLayer::getCost() {\n return *new doublev(_costv);\n}\n\n// This is called between microbatches\nvoid CostLayer::resetPassIdx() {\n Layer::resetPassIdx();\n _costv.clear();\n}\n\nCostLayer& CostLayer::make(ConvNetThread* convNetThread, PyObject* paramsDict, std::string& type, int replicaID) {\n if (type == \"cost.crossent\") {\n return *new CrossEntCostLayer(convNetThread, paramsDict, replicaID);\n } else if (type == \"cost.bce\") {\n return *new BinomialCrossEntropyCostLayer(convNetThread, paramsDict, replicaID);\n } else if (type == \"cost.dce\") {\n return *new DetectionCrossEntropyCostLayer(convNetThread, paramsDict, replicaID);\n } else if (type == \"cost.logreg\") {\n return *new LogregCostLayer(convNetThread, paramsDict, replicaID);\n } else if (type == \"cost.sum2\") {\n return *new SumOfSquaresCostLayer(convNetThread, paramsDict, replicaID);\n }\n throw std::string(\"Unknown cost layer type \") + type;\n}\n\n/*\n * =====================\n * CrossEntCostLayer\n * =====================\n */\nCrossEntCostLayer::CrossEntCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : CostLayer(convNetThread, paramsDict, replicaID, false) {\n}\n\nvoid CrossEntCostLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n // This layer uses its two inputs together\n if (inpIdx == 0) {\n NVMatrix& labels = *_inputs[0];\n NVMatrix& probs = *_inputs[1];\n int numCases = labels.getLeadingDim();\n computeCrossEntCost(labels, probs, _trueLabelLogProbs, _correctProbs);\n _costv.clear();\n _costv.push_back(-_trueLabelLogProbs.sum());\n _costv.push_back(numCases - _correctProbs.sum());\n }\n}\n\nvoid CrossEntCostLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(inpIdx == 1);\n LayerV& prev = _prev[replicaIdx];\n NVMatrix& labels = *_inputs[0];\n NVMatrix& probs = *_inputs[1];\n NVMatrix& target = prev[1]->getActsGrad();\n // Numerical stability optimization: if the layer below me is a softmax layer, let it handle\n // the entire gradient computation to avoid multiplying and dividing by a near-zero quantity.\n bool doWork = prev[1]->getNext().size() > 1 || prev[1]->getType() != \"softmax\" || prev[1]->getDeviceID() != getDeviceID();\n if (doWork) {\n computeCrossEntGrad(labels, probs, target, scaleTargets == 1, _coeff);\n }\n}\n\n/*\n * =====================\n * BinomialCrossEntropyCostLayer\n * =====================\n */\nBinomialCrossEntropyCostLayer::BinomialCrossEntropyCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : CostLayer(convNetThread, paramsDict, replicaID, false) {\n _computeSoftmaxErrorRate = pyDictGetInt(paramsDict, \"computeSoftmaxErrorRate\");\n _posWeight = pyDictGetFloat(paramsDict, \"posWeight\");\n}\n\nvoid BinomialCrossEntropyCostLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n // This layer uses its two inputs together\n if (inpIdx == 0) {\n NVMatrix& labels = *_inputs[0];\n NVMatrix& probs = *_inputs[1];\n int numCases = labels.getLeadingDim();\n labels.applyBinary(BinomialCrossEntOperator(_posWeight), probs, _tmpProbs);\n _costv.clear();\n // Cross-entropy cost\n _costv.push_back(-_tmpProbs.sum(_tmpbuf));// / labels.getFollowingDim());\n\n // If aggregated, we don't produce these outputs because they're not additive.\n // They have no meaning if this is just a partial cost.\n if (!_aggregated) {\n // \"Correct\" classifications. To compute these we threshold probs\n // and just count the number of entries that agree with labels.\n probs.biggerThanScalar(0.5, _tmpProbs);\n _tmpProbs.equals(labels);\n _costv.push_back((_tmpProbs.getNumElements() - _tmpProbs.sum(_tmpbuf)) / double(labels.getFollowingDim()));\n\n if (_computeSoftmaxErrorRate) {\n // Also compute top-1 error as if this is softmax and there's only one correct class\n probs.max(0, _tmpVec);\n assert(_tmpVec.getNumElements() == numCases); // Make sure we did max on correct axis\n probs.equalsVector(_tmpVec, _correctProbs);\n _correctProbs.sum(0, _tmpVec); // Divide by the # of labels that we predict as being present\n float m = _tmpVec.max();\n\n _correctProbs.eltwiseDivideByVector(_tmpVec);\n _correctProbs.eltwiseMult(labels);\n\n _costv.push_back(numCases - _correctProbs.sum(_tmpbuf));\n }\n }\n }\n}\n\nvoid BinomialCrossEntropyCostLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n assert(inpIdx == 1);\n LayerV& prev = _prev[replicaIdx];\n NVMatrix& labels = *_inputs[0];\n NVMatrix& probs = *_inputs[1];\n NVMatrix& target = prev[1]->getActsGrad();\n // Numerical stability optimization: if the layer below me is a logistic neuron layer, let it handle\n // the entire gradient computation to avoid multiplying and dividing by a near-zero quantity.\n bool doWork = prev[1]->getNext().size() > 1\n || prev[1]->getType() != \"neuron\"\n || static_cast(prev[1])->getNeuronType() != \"logistic\"\n || prev[1]->getDeviceID() != getDeviceID()\n || prev[1]->getNumReplicas() != getNumReplicas();\n if (doWork) {\n printf(\"Computing cross-entropy gradient the stupid way\\n\");\n if (scaleTargets == 0) {\n labels.applyBinary(BinomialCrossEntGradientOperator(_coeff, _posWeight), probs, target);\n } else {\n labels.applyTernary(AddGradientBinaryOperator(BinomialCrossEntGradientOperator(_coeff, _posWeight)), probs, target, target);\n }\n }\n}\n\nfloat BinomialCrossEntropyCostLayer::getPosWeight() {\n return _posWeight;\n}\n/*\n * =====================\n * DetectionCrossEntropyCostLayer\n * =====================\n */\nDetectionCrossEntropyCostLayer::DetectionCrossEntropyCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID)\n : BinomialCrossEntropyCostLayer(convNetThread, paramsDict, replicaID) {\n assert(!_aggregated);\n}\n\nvoid DetectionCrossEntropyCostLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n BinomialCrossEntropyCostLayer::fpropActs(inpIdx, scaleTargets, passType, passIdx);\n // This layer uses its two inputs together\n if (inpIdx == 0) {\n NVMatrix& labels = *_inputs[0];\n NVMatrix& probs = *_inputs[1];\n int numCases = labels.getLeadingDim();\n\n /*\n * Add information sufficient to compute precision and recall for each class.\n */\n // NOTE: _tmpProbs contains ((probs > 0.5) == labels)\n labels.sum(1, _numPositive); // sum(labels, 1)\n\n _tmpProbs.eltwiseMult(labels); // labels * ((probs > 0.5) == labels)\n _tmpProbs.sum(1, _numTruePositive);\n\n probs.biggerThanScalar(0.5, _tmpProbs);\n _tmpProbs.sum(1, _numDeclaredPositive);\n\n _numDeclaredPositive.copyToHost(_hNumDeclaredPositive, true);\n _numPositive.copyToHost(_hNumPositive, true);\n _numTruePositive.copyToHost(_hNumTruePositive, true);\n\n for (int i = 0; i < labels.getFollowingDim(); ++i) {\n _costv.push_back(_hNumDeclaredPositive(i, 0)); // 2\n _costv.push_back(_hNumPositive(i, 0)); // 3\n _costv.push_back(_hNumTruePositive(i, 0)); // 4\n }\n\n }\n}\n\n/*\n * =====================\n * LogregCostLayer\n * =====================\n */\nLogregCostLayer::LogregCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : CostLayer(convNetThread, paramsDict, replicaID, false) {\n _topk = pyDictGetInt(paramsDict, \"topk\");\n// _numAccumed = 0;\n}\n\nvoid LogregCostLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n // This layer uses its two inputs together\n if (inpIdx == 0) {\n NVMatrix& labels = *_inputs[0];\n NVMatrix* probs = _inputs[1];\n\n _doCompute = !IS_MULTIVIEW_TEST(passType);\n if (!_doCompute) {\n if (IS_MULTIVIEW_TEST_START(passType)) {\n if (_probsAccum.count(passIdx) == 0) {\n _probsAccum[passIdx] = new NVMatrix(*probs);\n }\n probs->copy(*_probsAccum[passIdx]);\n _numAccumed[passIdx] = 1;\n } else {\n _probsAccum[passIdx]->add(*probs);\n _numAccumed[passIdx] += 1;\n }\n if (IS_MULTIVIEW_TEST_END(passType)) {\n probs = _probsAccum[passIdx];\n probs->scale(1.0 / _numAccumed[passIdx]);\n _doCompute = true;\n }\n }\n if (_doCompute) {\n int numCases = labels.getNumElements();\n probs->max(0,_maxProbs);\n if (_topk == 1) {\n computeLogregCost(labels, *probs, _maxProbs, _trueLabelLogProbs, _correctProbs);\n } else {\n computeMultiSoftmaxCost(labels, *probs, _maxProbs, _trueLabelLogProbs, _correctProbs, _topkProbs, _topk);\n }\n _costv.clear();\n double top1 = _correctProbs.sum(_tmpbuf);\n\n _costv.push_back(-_trueLabelLogProbs.sum(_tmpbuf));\n _costv.push_back(numCases - top1);\n _costv.push_back(numCases - (_topk == 1 ? top1 : _topkProbs.sum(_tmpbuf)));\n\n }\n }\n}\n\nNVMatrix& LogregCostLayer::getProbsAccum(int replicaIdx) {\n return *_probsAccum[replicaIdx];\n}\n\nvoid LogregCostLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n if (inpIdx == 1) {\n LayerV& prev = _prev[replicaIdx];\n NVMatrix& labels = *_inputs[0];\n NVMatrix& probs = *_inputs[1];\n NVMatrix& target = prev[1]->getActsGrad();\n // Numerical stability optimization: if the layer below me is a softmax layer, let it handle\n // the entire gradient computation to avoid multiplying and dividing by a near-zero quantity.\n bool doWork = prev[1]->getNext().size() > 1 || prev[1]->getType() != \"softmax\"\n || prev[1]->getDeviceID() != getDeviceID() || prev[1]->getNumReplicas() != getNumReplicas();\n if (prev[1]->getType() == \"softmax\") {\n static_cast(prev[1])->setDoUpperGrad(!doWork);\n }\n if (doWork) {\n computeLogregGrad(labels, probs, target, scaleTargets == 1, _coeff);\n }\n }\n}\n\n/*\n * =====================\n * SumOfSquaresCostLayer\n * =====================\n */\nSumOfSquaresCostLayer::SumOfSquaresCostLayer(ConvNetThread* convNetThread, PyObject* paramsDict, int replicaID) : CostLayer(convNetThread, paramsDict, replicaID, false) {\n}\n\nvoid SumOfSquaresCostLayer::fpropActs(int inpIdx, float scaleTargets, PASS_TYPE passType, int passIdx) {\n _inputs[0]->apply(NVMatrixOps::Square(), _tmp);\n _costv.clear();\n _costv.push_back(_tmp.sum());\n}\n\nvoid SumOfSquaresCostLayer::bpropActs(NVMatrix& v, int replicaIdx, int inpIdx, float scaleTargets, PASS_TYPE passType) {\n _prev[replicaIdx][inpIdx]->getActsGrad().add(*_inputs[0], scaleTargets, -2 * _coeff);\n}\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/layer_kernels.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n#include \"../include/layer_kernels.cuh\"\n\nusing namespace std;\n\n/*\n * E = -log(y_t)\n * probs: (numOut, numCases)\n * labels: (1, numCases)\n * maxEnergies: (1, numCases)\n * labelLogProbs: (1, numCases) (*out)\n * correctProbs: (1, numCases) (*out)\n * top5Probs: (1, numCases) (*out)\n * \n * target: (1, numCases)\n * \n */\n__global__ void kMultiSoftmaxCost(float* probs, float* labels, float* maxProbs,\n float* labelLogProbs, float* correctProbs, float* top5Probs,\n const int numCases, const int numOut, const int setSize) {\n const int tx = blockIdx.x * LOGREG_ERR_THREADS_X + threadIdx.x;\n\n if (tx < numCases) {\n const int label = int(labels[tx]);\n const float maxp = maxProbs[tx];\n const float labelp = probs[label * numCases + tx];\n \n labelLogProbs[tx] = __logf(labelp);\n \n int numBiggerProbs = 0, numEqualsProbs = 0;\n for (int i = 0; i < numOut; ++i) {\n numBiggerProbs += probs[i * numCases + tx] > labelp;\n numEqualsProbs += probs[i * numCases + tx] == labelp;\n }\n\n const int slotsLeft = setSize - numBiggerProbs;\n \n top5Probs[tx] = slotsLeft <= 0.0f ? 0.0f : (numEqualsProbs <= slotsLeft ? 1.0f : float(slotsLeft) / numEqualsProbs);\n correctProbs[tx] = labelp != maxp ? 0.0f : 1.0f / float(numEqualsProbs);\n }\n}\n\n/*\n * E = -log(y_t)\n * probs: (numOut, numCases)\n * labels: (1, numCases)\n * maxProbs: (1, numCases)\n * labelLogProbs: (1, numCases) (*out)\n * correctProbs: (1, numCases) (*out)\n * top5Probs: (1, numCases) (*out)\n * \n * target: (1, numCases) == log(y_l[labels,:]\n */\nvoid computeMultiSoftmaxCost(NVMatrix& labels, NVMatrix& probs, NVMatrix& maxProbs, NVMatrix& labelLogProbs_out,\n NVMatrix& correctProbs_out, NVMatrix& top5Probs_out, int setSize) {\n int numCases = probs.getNumCols(); \n int numOut = probs.getNumRows(); \n\n assert(labels.getNumElements() == numCases);\n assert(!labels.isTrans());\n assert(!probs.isTrans());\n assert(labels.isContiguous());\n assert(probs.isContiguous());\n \n// NVMatrix& maxProbs = probs.max(0);\n \n labelLogProbs_out.resize(1, numCases);\n correctProbs_out.resize(1, numCases);\n top5Probs_out.resize(1, numCases);\n dim3 threads(LOGREG_ERR_THREADS_X, 1);\n dim3 blocks(DIVUP(numCases, LOGREG_ERR_THREADS_X), 1);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n\n cudaFuncSetCacheConfig(kMultiSoftmaxCost, cudaFuncCachePreferL1);\n kMultiSoftmaxCost<<>>(probs.getDevData(), labels.getDevData(), maxProbs.getDevData(),\n labelLogProbs_out.getDevData(), correctProbs_out.getDevData(), top5Probs_out.getDevData(),\n numCases, numOut, setSize);\n\n getLastCudaError(\"kMultiSoftmaxCost: Kernel execution failed\");\n// cudaThreadSynchronize();\n}\n\n/*\n * E = sum(p_l * log(y_l))\n * probs: (numOut, numCases)\n * labels: (numOut, numCases)\n * maxProbs: (1, numCases)\n * labelLogProbs: (1, numCases) (*out)\n * correctProbs: (1, numCases) (*out)\n * \n * target: (1, numCases)\n */\n__global__ void kCrossEntCost(float* probs, float* labels, float* maxProbs, float* labelLogProbs, float* correctProbs,\n const int numCases, const int numOut) {\n const int tx = blockIdx.x * LOGREG_ERR_THREADS_X + threadIdx.x;\n\n if (tx < numCases) {\n probs += tx;\n labels += tx;\n maxProbs += tx;\n labelLogProbs += tx;\n correctProbs += tx;\n \n const float maxp = maxProbs[0];\n\n /*\n * Compute the probability of guessing the correct case if you take the most-probable label.\n * \n * This is done like this:\n * \n * - If the most probable label is not equal to the true label, then the probability is zero.\n * - Otherwise, the probability is 1 / (number of labels whose probability is equal to the maximum).\n * \n * This is certainly overkill -- in practice, it's just about impossible for two labels to get assigned\n * maximum probability. But it's a safety measure to prevent over-estimating your accuracy.\n * Though it could never happen in reality. Well it could. But it wouldn't. Cool?\n */\n float crossEnt = 0.0f;\n int numMax = 0;\n bool correctLabel = false;\n for (int i = 0; i < numOut; i++) {\n const float label_prob = labels[i * numCases];\n const float model_prob = probs[i * numCases];\n numMax += model_prob == maxp;\n crossEnt += label_prob * safelog(model_prob);\n correctLabel |= model_prob == maxp && label_prob > 0.0f;\n }\n labelLogProbs[0] = crossEnt;\n if (!correctLabel) {\n correctProbs[0] = 0.0f;\n } else {\n correctProbs[0] = 1.0f / float(numMax);\n }\n }\n}\n\n/*\n * E = sum(p_l * log(y_l))\n * y_l: (numOut, numCases)\n * labels: (numOut, numCases)\n * \n * dE_dy_l: (numOut, numCases)\n */\ntemplate \n__global__ void kCrossEntGrad(float* y_l, float* labels, float* dE_dy_l, const int numCases,\n const int numOut, const float gradCoeff) {\n const int tx = blockIdx.x * LOGREG_GRAD_THREADS_X + threadIdx.x;\n const int ty = blockIdx.y * LOGREG_GRAD_THREADS_Y + threadIdx.y;\n const int tidx = ty * numCases + tx;\n \n if (ty < numOut && tx < numCases) {\n const float label_prob = labels[tidx];\n const float model_prob = y_l[tidx];\n const float v = gradCoeff * __fdividef(label_prob, model_prob);\n if (add) {\n dE_dy_l[tidx] += v;\n } else {\n dE_dy_l[tidx] = v;\n }\n }\n}\n\n/*\n * E = sum(p_l * log(y_l))\n * y_l: (numOut, numCases)\n * labels: (numOut, numCases)\n * \n * dE_dx_l: (numOut, numCases)\n */\ntemplate \n__global__ void kCrossEntSoftmaxGrad(float* y_l, float* labels, float* dE_dx_l, const int numCases,\n const int numOut, const float gradCoeff) {\n const int tx = blockIdx.x * LOGREG_GRAD_THREADS_X + threadIdx.x;\n const int ty = blockIdx.y * LOGREG_GRAD_THREADS_Y + threadIdx.y;\n const int tidx = ty * numCases + tx;\n \n if (ty < numOut && tx < numCases) {\n const float model_prob = y_l[tidx];\n const float label_prob = labels[tidx];\n float v = gradCoeff * (label_prob - model_prob);\n if (add) {\n dE_dx_l[tidx] += v;\n } else {\n dE_dx_l[tidx] = v;\n }\n }\n}\n\n/*\n * E = -log(y_t)\n * probs: (numOut, numCases)\n * labels: (1, numCases)\n * maxProbs: (1, numCases)\n * labelLogProbs: (1, numCases) (*out)\n * correctProbs: (1, numCases) (*out)\n * \n * target: (1, numCases)\n */\n__global__ void kLogregCost(float* probs, float* labels, float* maxProbs, float* labelLogProbs, float* correctProbs,\n const int numCases, const int numOut) {\n const int tx = blockIdx.x * LOGREG_ERR_THREADS_X + threadIdx.x;\n\n if (tx < numCases) {\n const int label = int(labels[tx]);\n const float maxp = maxProbs[tx];\n const float labelp = probs[label * numCases + tx];\n \n labelLogProbs[tx] = __logf(labelp);\n \n /*\n * Compute the probability of guessing the correct case if you take the most-probable label.\n * \n * This is done like this:\n * \n * - If the most probable label is not equal to the true label, then the probability is zero.\n * - Otherwise, the probability is 1 / (number of labels whose probability is equal to the maximum).\n * \n * This is certainly overkill -- in practice, it's just about impossible for two labels to get assigned\n * maximum probability. But it's a safety measure to prevent over-estimating your accuracy.\n * Though it could never happen in reality. Well it could. But it wouldn't. Cool?\n */\n if (labelp != maxp) {\n correctProbs[tx] = 0;\n } else {\n int numMax = 0;\n for (int i = 0; i < numOut; i++) {\n numMax += probs[i * numCases + tx] == maxp;\n }\n correctProbs[tx] = 1.0f / float(numMax);\n }\n }\n}\n\n/*\n * E = -log(y_t)\n * y_l: (numOut, numCases)\n * labels: (1, numCases)\n * \n * dE_dy_l: (numOut, numCases)\n */\ntemplate \n__global__ void kLogregCostGrad(float* y_l, float* labels, float* dE_dy_l, const int numCases,\n const int numOut, const float gradCoeff) {\n const int tx = blockIdx.x * LOGREG_GRAD_THREADS_X + threadIdx.x;\n const int ty = blockIdx.y * LOGREG_GRAD_THREADS_Y + threadIdx.y;\n const int tidx = ty * numCases + tx;\n \n if (ty < numOut && tx < numCases) {\n const int label = int(labels[tx]);\n float v = gradCoeff * (label == ty);\n v = __fdividef(v, y_l[tidx]);\n if (add) {\n dE_dy_l[tidx] += v;\n } else {\n dE_dy_l[tidx] = v;\n }\n }\n}\n\n/*\n * E = -log(y_t)\n * y_l: (numOut, numCases)\n * labels: (1, numCases)\n * \n * dE_dx_l: (numOut, numCases)\n */\ntemplate \n__global__ void kLogregSoftmaxGrad(float* y_l, float* labels, float* dE_dx_l, const int numCases,\n const int numOut, const float gradCoeff) {\n const int tx = blockIdx.x * LOGREG_GRAD_THREADS_X + threadIdx.x;\n const int ty = blockIdx.y * LOGREG_GRAD_THREADS_Y + threadIdx.y;\n const int tidx = ty * numCases + tx;\n \n if (ty < numOut && tx < numCases) {\n const int label = int(labels[tx]);\n float v = gradCoeff * ((label == ty) - y_l[tidx]);\n if (add) {\n dE_dx_l[tidx] += v;\n } else {\n dE_dx_l[tidx] = v;\n }\n }\n}\n\n/*\n * dE_dy_l: (numOut, numCases)\n * y_l: (numOut, numCases)\n * \n * dE_dx_l: (numOut, numCases)\n */\ntemplate \n__global__ void kSoftmaxGrad(float* dE_dy_l, float* y_l, float* dE_dx_l, const int numCases, const int numOut, const float scaleTarget, const float scaleGrad) {\n const int tx = blockIdx.x * LOGREG_GRAD_THREADS_X + threadIdx.x;\n const int ty = blockIdx.y * LOGREG_GRAD_THREADS_Y + threadIdx.y;\n const int tidx = ty * numCases + tx;\n \n if (ty < numOut && tx < numCases) {\n float v = 0;\n for (int j = 0; j < numOut; j++) {\n v += dE_dy_l[j * numCases + tx] * ((j == ty) - y_l[j * numCases + tx]);\n }\n v *= y_l[tidx];\n \n if (add) {\n dE_dx_l[tidx] = scaleTarget * dE_dx_l[tidx] + scaleGrad * v;\n } else {\n dE_dx_l[tidx] = scaleGrad * v;\n }\n }\n}\n\ntemplate \n__global__ void kEltwiseMaxGrad(float* actGrad, float* input, float* output, float* target,\n const int numElements) {\n for (int i = B_X * blockIdx.x + threadIdx.x; i < numElements; i += B_X * gridDim.x) {\n if (add) {\n target[i] += actGrad[i] * (output[i] == input[i]);\n } else {\n target[i] = actGrad[i] * (output[i] == input[i]);\n }\n }\n}\n\nvoid computeEltwiseMaxGrad(NVMatrix& actGrad, NVMatrix& input, NVMatrix& output, NVMatrix& target, bool add) {\n assert(actGrad.isContiguous());\n assert(output.isContiguous());\n assert(input.isContiguous());\n assert(actGrad.isSameDims(input));\n assert(actGrad.isSameDims(output));\n \n dim3 blocks(DIVUP(actGrad.getNumElements(), 128));\n dim3 threads(128);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (add) {\n assert(actGrad.isSameDims(target));\n cudaFuncSetCacheConfig(kEltwiseMaxGrad<128, true>, cudaFuncCachePreferL1);\n kEltwiseMaxGrad<128, true><<>>(actGrad.getDevData(), input.getDevData(), output.getDevData(), target.getDevData(), actGrad.getNumElements());\n } else {\n target.resize(actGrad);\n cudaFuncSetCacheConfig(kEltwiseMaxGrad<128, false>, cudaFuncCachePreferL1);\n kEltwiseMaxGrad<128, false><<>>(actGrad.getDevData(), input.getDevData(), output.getDevData(), target.getDevData(), actGrad.getNumElements());\n }\n \n getLastCudaError(\"computeEltwiseMaxGrad: Kernel execution failed\");\n}\n\n/*\n * E = sum_i{-p_i*log(y_i)}\n * probs: (numOut, numCases)\n * labels: (numOut, numCases)\n * maxProbs: (1, numCases)\n * labelLogProbs: (1, numCases) (*out)\n * correctProbs: (1, numCases) (*out)\n * \n * target: (1, numCases)\n */\nvoid computeCrossEntCost(NVMatrix& labels, NVMatrix& probs, NVMatrix& labelLogProbs_out, NVMatrix& correctProbs_out) {\n int numCases = probs.getNumCols(); \n int numOut = probs.getNumRows(); \n\n assert(labels.isSameDims(probs));\n assert(!labels.isTrans());\n assert(!probs.isTrans());\n assert(labels.isContiguous());\n assert(probs.isContiguous());\n \n NVMatrix& maxProbs = probs.max(0);\n \n labelLogProbs_out.resize(1, numCases);\n correctProbs_out.resize(1, numCases);\n dim3 threads(LOGREG_ERR_THREADS_X, 1);\n dim3 blocks(DIVUP(numCases, LOGREG_ERR_THREADS_X), 1);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n cudaFuncSetCacheConfig(kCrossEntCost, cudaFuncCachePreferL1);\n kCrossEntCost<<>>(probs.getDevData(), labels.getDevData(), maxProbs.getDevData(),\n labelLogProbs_out.getDevData(), correctProbs_out.getDevData(),\n numCases, numOut);\n getLastCudaError(\"kCrossEntCost: Kernel execution failed\");\n\n delete &maxProbs;\n}\n\nvoid computeCrossEntGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff) {\n int numCases = probs.getLeadingDim(); \n int numOut = probs.getFollowingDim(); \n assert(labels.isSameDims(probs));\n assert(probs.isContiguous());\n assert(target.isContiguous());\n assert(labels.isContiguous());\n assert(!labels.isTrans());\n assert(!probs.isTrans());\n \n dim3 threads(LOGREG_GRAD_THREADS_X, LOGREG_GRAD_THREADS_Y);\n dim3 blocks(DIVUP(numCases, LOGREG_GRAD_THREADS_X), DIVUP(numOut, LOGREG_GRAD_THREADS_Y));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (!add) {\n target.resize(probs);\n kCrossEntGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n } else {\n kCrossEntGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n }\n\n getLastCudaError(\"kCrossEntGrad: Kernel execution failed\");\n}\n\nvoid computeSoftmaxGrad(NVMatrix& acts, NVMatrix& actsGrad, NVMatrix& target, float scaleTarget, float scaleGrad) {\n int numCases = acts.getLeadingDim();\n int numOut = acts.getFollowingDim();\n\n assert(acts.isSameDims(actsGrad));\n assert(acts.isContiguous());\n assert(actsGrad.isContiguous());\n assert(target.isContiguous());\n assert(acts.isTrans());\n assert(actsGrad.isTrans());\n\n dim3 threads(LOGREG_GRAD_THREADS_X, LOGREG_GRAD_THREADS_Y);\n dim3 blocks(DIVUP(numCases, LOGREG_GRAD_THREADS_X), DIVUP(numOut, LOGREG_GRAD_THREADS_Y));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n\n if (scaleTarget == 0) {\n target.resize(acts);\n kSoftmaxGrad<<>>(actsGrad.getDevData(), acts.getDevData(), target.getDevData(), numCases, numOut, scaleTarget, scaleGrad);\n } else {\n kSoftmaxGrad<<>>(actsGrad.getDevData(), acts.getDevData(), target.getDevData(), numCases, numOut, scaleTarget, scaleGrad);\n }\n getLastCudaError(\"computeSoftmaxGrad: Kernel execution failed\");\n}\n\nvoid computeCrossEntSoftmaxGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff) {\n int numCases = probs.getLeadingDim(); \n int numOut = probs.getFollowingDim(); \n assert(labels.getLeadingDim() == probs.getLeadingDim() && labels.getFollowingDim() == probs.getFollowingDim());\n assert(probs.isContiguous());\n assert(target.isContiguous());\n assert(labels.isContiguous());\n assert(probs.isTrans());\n assert(!labels.isTrans());\n \n dim3 threads(LOGREG_GRAD_THREADS_X, LOGREG_GRAD_THREADS_Y);\n dim3 blocks(DIVUP(numCases, LOGREG_GRAD_THREADS_X), DIVUP(numOut, LOGREG_GRAD_THREADS_Y));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (!add) {\n target.resize(probs);\n cudaFuncSetCacheConfig(kCrossEntSoftmaxGrad, cudaFuncCachePreferL1);\n kCrossEntSoftmaxGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n } else {\n cudaFuncSetCacheConfig(kCrossEntSoftmaxGrad, cudaFuncCachePreferL1);\n kCrossEntSoftmaxGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n }\n getLastCudaError(\"kCrossEntSoftmaxGrad: Kernel execution failed\");\n}\n\n/*\n * E = -log(y_t)\n * probs: (numOut, numCases)\n * labels: (1, numCases)\n * maxProbs: (1, numCases)\n * labelLogProbs: (1, numCases) (*out)\n * correctProbs: (1, numCases) (*out)\n * \n * target: (1, numCases) == log(y_l[labels,:]\n */\nvoid computeLogregCost(NVMatrix& labels, NVMatrix& probs, NVMatrix& maxProbs, NVMatrix& labelLogProbs_out, NVMatrix& correctProbs_out) {\n int numCases = probs.getNumCols(); \n int numOut = probs.getNumRows(); \n\n assert(labels.getNumElements() == numCases);\n assert(!labels.isTrans());\n assert(!probs.isTrans());\n assert(labels.isContiguous());\n assert(probs.isContiguous());\n\n labelLogProbs_out.resize(1, numCases);\n correctProbs_out.resize(1, numCases);\n dim3 threads(LOGREG_ERR_THREADS_X, 1);\n dim3 blocks(DIVUP(numCases, LOGREG_ERR_THREADS_X), 1);\n cudaStream_t stream = NVMatrix::getDefaultStream();\n cudaFuncSetCacheConfig(kLogregCost, cudaFuncCachePreferL1);\n kLogregCost<<>>(probs.getDevData(), labels.getDevData(), maxProbs.getDevData(),\n labelLogProbs_out.getDevData(), correctProbs_out.getDevData(),\n numCases, numOut);\n getLastCudaError(\"computeLogregCost: Kernel execution failed\");\n}\n\nvoid computeLogregGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff) {\n int numCases = probs.getLeadingDim(); \n int numOut = probs.getFollowingDim(); \n assert(labels.getNumElements() == numCases);\n assert(probs.isContiguous());\n assert(target.isContiguous());\n assert(labels.isContiguous());\n assert(!labels.isTrans());\n assert(!probs.isTrans());\n \n dim3 threads(LOGREG_GRAD_THREADS_X, LOGREG_GRAD_THREADS_Y);\n dim3 blocks(DIVUP(numCases, LOGREG_GRAD_THREADS_X), DIVUP(numOut, LOGREG_GRAD_THREADS_Y));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (!add) {\n target.resize(probs);\n kLogregCostGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n } else {\n kLogregCostGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n }\n\n getLastCudaError(\"computeLogregGrad: Kernel execution failed\");\n}\n\nvoid computeLogregSoftmaxGrad(NVMatrix& labels, NVMatrix& probs, NVMatrix& target, bool add, float coeff) {\n int numCases = probs.getLeadingDim(); \n int numOut = probs.getFollowingDim(); \n assert(labels.getNumElements() == numCases);\n assert(probs.isContiguous());\n assert(target.isContiguous());\n assert(labels.isContiguous());\n assert(probs.isTrans());\n \n dim3 threads(LOGREG_GRAD_THREADS_X, LOGREG_GRAD_THREADS_Y);\n dim3 blocks(DIVUP(numCases, LOGREG_GRAD_THREADS_X), DIVUP(numOut, LOGREG_GRAD_THREADS_Y));\n cudaStream_t stream = NVMatrix::getDefaultStream();\n if (!add) {\n target.resize(probs);\n kLogregSoftmaxGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n } else {\n kLogregSoftmaxGrad<<>>(probs.getDevData(), labels.getDevData(), target.getDevData(),\n numCases, numOut, coeff);\n }\n\n getLastCudaError(\"computeLogregSoftmaxGrad: Kernel execution failed\");\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/lr.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \"../include/lr.cuh\"\n#include \"../include/util.cuh\"\n\n/*\n * ==================================\n * ParameterSchedule\n * ==================================\n */\nParameterSchedule& ParameterSchedule::make(PyObject* schedDict) {\n std::string type = pyDictGetString(schedDict, \"type\");\n PyObject* paramsDict = PyDict_GetItemString(schedDict, \"params\");\n double base = pyDictGetFloat(paramsDict, \"base\");\n if (type == \"const\") {\n return *new ParameterSchedule(base);\n } else {\n double tgtFactor = pyDictGetFloat(paramsDict, \"tgtFactor\");\n if (type == \"linear\") {\n return *new LinearParameterSchedule(base, tgtFactor);\n } else if (type == \"exp\") {\n return *new ExpParameterSchedule(base, tgtFactor);\n } else if (type == \"dexp\") {\n double numSteps = pyDictGetInt(paramsDict, \"numSteps\");\n return *new DiscreteExpParameterSchedule(base, tgtFactor, numSteps);\n }\n }\n throw std::string(\"Unknown learning rate schedule type \") + type;\n}\n\nParameterSchedule::ParameterSchedule(double baseRate)\n : _baseRate(baseRate) {\n}\n\ndouble ParameterSchedule::getValue(double progress) {\n return _baseRate;\n}\n\ndouble ParameterSchedule::getBaseValue() const {\n return _baseRate;\n}\n\nParameterSchedule::~ParameterSchedule() {\n}\n\n/*\n * ==================================\n * LinearParameterSchedule\n * ==================================\n */\nLinearParameterSchedule::LinearParameterSchedule(double baseRate, double tgtFactor)\n: ParameterSchedule(baseRate) {\n _finalRate = baseRate / tgtFactor;\n}\n\ndouble LinearParameterSchedule::getValue(double progress) {\n return _baseRate * (1 - progress) + _finalRate * progress;\n}\n\n/*\n * ==================================\n * ExpParameterSchedule\n * ==================================\n */\nExpParameterSchedule::ExpParameterSchedule(double baseRate, double tgtFactor)\n: ParameterSchedule(baseRate) {\n _powBase = 1.0 / tgtFactor;\n}\n\ndouble ExpParameterSchedule::getValue(double progress) {\n return _baseRate * std::pow(_powBase, progress);\n}\n\n/*\n * ==================================\n * DiscreteExpParameterSchedule\n * ==================================\n */\nDiscreteExpParameterSchedule::DiscreteExpParameterSchedule(double baseRate, double tgtFactor, int numSteps)\n: ParameterSchedule(baseRate) {\n ExpParameterSchedule elrs(baseRate, tgtFactor);\n double finalRate = baseRate / tgtFactor;\n for (int i = 0; i < numSteps - 1; i++) {\n double progress = double(i) / (numSteps - 1);\n _rates.push_back(elrs.getValue(progress));\n }\n _rates.push_back(finalRate);\n //printf(\"initialized base %e, final %e, stpes %d\\n\", baseRate, finalRate, numSteps);\n}\n\ndouble DiscreteExpParameterSchedule::getValue(double progress) {\n for (int i = 0; i < _rates.size(); ++i) {\n if (progress <= double(i + 1) / _rates.size()) {\n return _rates[i];\n }\n }\n return _rates.back();\n}\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/memorysource.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/memorysource.cuh\"\n\nusing namespace std;\n\n/*\n * =======================\n * MemoryView\n * =======================\n */\nMemoryView::MemoryView(MemorySource& src, std::string& name) : _src(&src), _name(name) {\n}\n\nMemoryView::~MemoryView() {\n// if (_src->truncate(_name)) {\n// delete _src;\n// }\n}\n\nNVMatrix& MemoryView::getMemory(int numCases) {\n return _src->getMemory(_name, numCases);\n}\n\nNVMatrix& MemoryView::getMemory() {\n return _src->getMemory(_name);\n}\n\nMemorySource& MemoryView::getMemorySource() {\n return *_src;\n}\n\nbool MemoryView::isParent() {\n return _src->getRange(_name).first == 0 && _src->getRange(_name).second == _src->getSize();\n}\n\nstd::string& MemoryView::getName() {\n return _name;\n}\n\nMemoryView& MemoryView::clone(std::string& name) {\n return _src->addUser(name, _src->getRange(_name));\n}\n\n/*\n * =======================\n * MemorySource\n * =======================\n */\nMemorySource::MemorySource(int size, int deviceID) : _size(size), _deviceID(deviceID) {\n}\n\nMemorySource::~MemorySource() {\n // Each MemoryView is deleted by owner Layer, and the last one deletes the MemorySource.\n // So this is a no-op.\n}\n\nNVMatrix& MemorySource::getMemory(std::string& name) {\n return getMemory(name, _memory.getLeadingDim());\n}\n\n// Deletes old view when appropriate\nNVMatrix& MemorySource::getMemory(std::string& name, int numCases) {\n numCases = numCases < 0 ? _memory.getLeadingDim() : numCases;\n _lock.acquire();\n if (_memory.getLeadingDim() != numCases || _memory.getFollowingDim() != _size) {\n int d = NVMatrix::getDeviceID();\n NVMatrix::setDeviceID(_deviceID);\n _memory.resize(_size, numCases, false);\n for (map::const_iterator it = _memoryViews.begin(); it != _memoryViews.end(); ++it) {\n delete it->second;\n }\n _memoryViews.clear();\n if (d >= 0) {\n NVMatrix::setDeviceID(d);\n }\n }\n if (_memoryViews.count(name) == 0) {\n assert(!_memory.isTrans());\n _memoryViews[name] = &_memory.sliceRows(_viewRanges[name].first, _viewRanges[name].second);\n }\n NVMatrix& view = *_memoryViews[name];\n assert(view.isContiguous());\n _lock.release();\n return view;\n}\n\nMemoryView& MemorySource::addUser(std::string& name, std::pair range) {\n assert(_viewRanges.count(name) == 0);\n _viewRanges[name] = range;\n return *new MemoryView(*this, name);\n}\n\nMemoryView& MemorySource::addUser(std::string& name) {\n return addUser(name, std::pair(0, _size));\n}\n\nMemoryView& MemorySource::make(int size, int deviceID, std::string& parentUser) {\n return (new MemorySource(size, deviceID))->addUser(parentUser);\n}\n\npair MemorySource::getRange(std::string& name) {\n return _viewRanges[name];\n}\n\nint MemorySource::getSize() {\n return _size;\n}\n\nbool MemorySource::truncate(std::string& name) {\n bool truncated = false;\n _lock.acquire();\n _truncateRequests.insert(name);\n if (_truncateRequests.size() == _viewRanges.size()) {\n for (map::const_iterator it = _memoryViews.begin(); it != _memoryViews.end(); ++it) {\n delete it->second;\n }\n _memoryViews.clear();\n _memory.truncate();\n _truncateRequests.clear();\n truncated = true;\n }\n _lock.release();\n return truncated;\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/neuron.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/neuron.cuh\"\n#include \"../include/util.cuh\"\n\nusing namespace std;\n\nNeuron& Neuron::makeNeuron(PyObject* neuronDict) {\n std::string type = pyDictGetString(neuronDict, \"type\");\n PyObject* neuronParamsDict = PyDict_GetItemString(neuronDict, \"params\");\n \n if (type == \"relu\") {\n return *new ReluNeuron();\n }\n \n if (type == \"drelu\") {\n return *new DoubleReluNeuron(pyDictGetFloat(neuronParamsDict, \"a\"));\n }\n \n if (type == \"softrelu\") {\n return *new SoftReluNeuron();\n }\n \n if (type == \"brelu\") {\n return *new BoundedReluNeuron(pyDictGetFloat(neuronParamsDict, \"a\"));\n }\n\n if (type == \"abs\") {\n return *new AbsNeuron();\n }\n\n if (type == \"logistic\") {\n return *new LogisticNeuron();\n }\n \n if (type == \"tanh\") {\n return *new TanhNeuron(pyDictGetFloat(neuronParamsDict, \"a\"), pyDictGetFloat(neuronParamsDict, \"b\"));\n }\n \n if (type == \"square\") {\n return *new SquareNeuron();\n }\n \n if (type == \"sqrt\") {\n return *new SqrtNeuron();\n }\n \n if (type == \"linear\") {\n return *new LinearNeuron(pyDictGetFloat(neuronParamsDict, \"a\"), pyDictGetFloat(neuronParamsDict, \"b\"));\n }\n\n if (type == \"log\") {\n return *new LogNeuron(pyDictGetFloat(neuronParamsDict, \"a\"));\n }\n\n if (type == \"ident\") {\n return *new Neuron();\n }\n \n throw std::string(\"Unknown neuron type: \") + type;\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/pyconvnet.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"../../util/include/matrix.h\"\n#include \"../../util/include/queue.h\"\n#include \"../include/worker.cuh\"\n#include \"../include/util.cuh\"\n#include \"../include/cost.cuh\"\n\n#include \"../include/pyconvnet.cuh\"\n#include \"../include/convnet.cuh\"\n\n#include \"../include/jpeg.h\"\n\nusing namespace std;\nstatic ConvNet* model = NULL;\n\nstatic PyMethodDef _ConvNetMethods[] = {{ \"initModel\", initModel, METH_VARARGS },\n { \"startBatch\", startBatch, METH_VARARGS },\n { \"finishBatch\", finishBatch, METH_VARARGS },\n { \"checkGradients\", checkGradients, METH_VARARGS },\n { \"startMultiviewTest\", startMultiviewTest, METH_VARARGS },\n { \"startFeatureWriter\", startFeatureWriter, METH_VARARGS },\n { \"startDataGrad\", startDataGrad, METH_VARARGS },\n { \"syncWithHost\", syncWithHost, METH_VARARGS },\n { \"decodeJpeg\", decodeJpeg, METH_VARARGS },\n { NULL, NULL }\n};\n\nvoid init_ConvNet() {\n (void) Py_InitModule(\"_ConvNet\", _ConvNetMethods);\n import_array();\n}\n\nvoid signalHandler(int sig) {\n const size_t max_trace_size = 40;\n void *array[max_trace_size];\n size_t trace_size = backtrace(array, max_trace_size);\n fprintf(stderr, \"Error signal %d:\\n\", sig);\n backtrace_symbols_fd(array, trace_size, STDERR_FILENO);\n exit(1);\n}\n\nPyObject* initModel(PyObject *self, PyObject *args) {\n assert(model == NULL);\n signal(SIGSEGV, signalHandler);\n signal(SIGABRT, signalHandler);\n\n PyDictObject* pyLayerParams;\n PyListObject* pyDeviceIDs;\n int pyMinibatchSize;\n int conserveMem;\n\n if (!PyArg_ParseTuple(args, \"O!O!ii\",\n &PyDict_Type, &pyLayerParams,\n &PyList_Type, &pyDeviceIDs,\n &pyMinibatchSize,\n &conserveMem)) {\n return NULL;\n }\n intv& deviceIDs = *getIntV((PyObject*)pyDeviceIDs);\n\n model = new ConvNet((PyObject*)pyLayerParams,\n deviceIDs,\n pyMinibatchSize,\n conserveMem);\n\n model->start();\n return Py_BuildValue(\"i\", 0);\n}\n\n/*\n * Starts training/testing on the given batch (asynchronous -- returns immediately).\n */\nPyObject* startBatch(PyObject *self, PyObject *args) {\n assert(model != NULL);\n// printf(\"starting next batch\\n\");\n PyListObject* data;\n double progress;\n int test = 0;\n if (!PyArg_ParseTuple(args, \"O!d|i\",\n &PyList_Type, &data,\n &progress,\n &test)) {\n return NULL;\n }\n CPUData* cpuData = new CPUData((PyObject*)data);\n \n TrainingWorker* wr = new TrainingWorker(*model, *cpuData, progress, test);\n model->getWorkerQueue().enqueue(wr);\n return Py_BuildValue(\"i\", 0);\n}\n\n/*\n * Starts testing on the given batch (asynchronous -- returns immediately).\n */\nPyObject* startMultiviewTest(PyObject *self, PyObject *args) {\n assert(model != NULL);\n PyListObject* data;\n int numViews;\n PyArrayObject* pyProbs = NULL;\n char* logregName = NULL;\n if (!PyArg_ParseTuple(args, \"O!i|O!s\",\n &PyList_Type, &data,\n &numViews,\n &PyArray_Type, &pyProbs,\n &logregName)) {\n return NULL;\n }\n CPUData* cpuData = new CPUData((PyObject*)data);\n MultiviewTestWorker* wr = pyProbs == NULL ? new MultiviewTestWorker(*model, *cpuData, numViews)\n : new MultiviewTestWorker(*model, *cpuData, numViews, *new Matrix(pyProbs), logregName);\n model->getWorkerQueue().enqueue(wr);\n return Py_BuildValue(\"i\", 0);\n}\n\nPyObject* startFeatureWriter(PyObject *self, PyObject *args) {\n assert(model != NULL);\n PyListObject* data;\n PyListObject* pyFtrs;\n PyListObject* pyLayerNames;\n if (!PyArg_ParseTuple(args, \"O!O!O!\",\n &PyList_Type, &data,\n &PyList_Type, &pyFtrs,\n &PyList_Type, &pyLayerNames)) {\n return NULL;\n }\n stringv* layerNames = getStringV((PyObject*)pyLayerNames);\n CPUData* cpuData = new CPUData((PyObject*)data);\n MatrixV* ftrs = getMatrixV((PyObject*)pyFtrs);\n \n FeatureWorker* wr = new FeatureWorker(*model, *cpuData, *ftrs, *layerNames);\n model->getWorkerQueue().enqueue(wr);\n return Py_BuildValue(\"i\", 0);\n}\n\nPyObject* startDataGrad(PyObject *self, PyObject *args) {\n// assert(model != NULL);\n// PyListObject* data;\n// int dataLayerIdx, softmaxLayerIdx;\n// if (!PyArg_ParseTuple(args, \"O!ii\",\n// &PyList_Type, &data,\n// &dataLayerIdx, &softmaxLayerIdx)) {\n// return NULL;\n// }\n// CPUData* cpuData = new CPUData((PyObject*)data);\n// Matrix& ftrs = *mvec.back();\n// mvec.pop_back();\n// \n// DataGradWorker* wr = new DataGradWorker(*model, *cpuData, ftrs, dataLayerIdx, softmaxLayerIdx);\n// model->getWorkerQueue().enqueue(wr);\n return Py_BuildValue(\"i\", 0);\n}\n\n/*\n * Waits for the trainer to finish training on the batch given to startBatch.\n * This is a blocking call so lets release the GIL.\n */\nPyObject* finishBatch(PyObject *self, PyObject *args) {\n assert(model != NULL);\n WorkResult* res = model->getResultQueue().dequeue();\n assert(res != NULL);\n assert(res->getResultType() == WorkResult::BATCH_DONE);\n \n Cost& cost = res->getResults();\n PyObject* dict = PyDict_New();\n CostMap& costMap = cost.getCostMap();\n for (CostMap::const_iterator it = costMap.begin(); it != costMap.end(); ++it) {\n PyObject* v = PyList_New(0);\n for (vector::const_iterator iv = it->second->begin(); iv != it->second->end(); ++iv) {\n PyObject* f = PyFloat_FromDouble(*iv);\n PyList_Append(v, f);\n }\n PyDict_SetItemString(dict, it->first.c_str(), v);\n }\n PyObject* retVal = Py_BuildValue(\"Ni\", dict, cost.getNumCases());\n delete res; // Deletes cost too\n \n return retVal;\n}\n\nPyObject* checkGradients(PyObject *self, PyObject *args) {\n assert(model != NULL);\n PyListObject* data;\n if (!PyArg_ParseTuple(args, \"O!\",\n &PyList_Type, &data)) {\n return NULL;\n }\n CPUData* cpuData = new CPUData((PyObject*)data);\n \n GradCheckWorker* wr = new GradCheckWorker(*model, *cpuData);\n model->getWorkerQueue().enqueue(wr);\n WorkResult* res = model->getResultQueue().dequeue();\n assert(res != NULL);\n assert(res->getResultType() == WorkResult::BATCH_DONE);\n delete res;\n return Py_BuildValue(\"i\", 0);\n}\n\n/*\n * Copies weight matrices from GPU to system memory.\n */\nPyObject* syncWithHost(PyObject *self, PyObject *args) {\n assert(model != NULL);\n SyncWorker* wr = new SyncWorker(*model);\n model->getWorkerQueue().enqueue(wr);\n WorkResult* res = model->getResultQueue().dequeue();\n assert(res != NULL);\n assert(res->getResultType() == WorkResult::SYNC_DONE);\n \n delete res;\n return Py_BuildValue(\"i\", 0);\n}\n\nPyObject* decodeJpeg(PyObject *self, PyObject *args) {\n PyListObject* pyJpegStrings;\n PyArrayObject* pyTarget;\n int img_size, inner_size, test, multiview;\n if (!PyArg_ParseTuple(args, \"O!O!iiii\",\n &PyList_Type, &pyJpegStrings,\n &PyArray_Type, &pyTarget,\n &img_size,\n &inner_size,\n &test,\n &multiview)) {\n return NULL;\n }\n\n Thread* threads[NUM_JPEG_DECODER_THREADS];\n int num_imgs = PyList_GET_SIZE(pyJpegStrings);\n int num_imgs_per_thread = DIVUP(num_imgs, NUM_JPEG_DECODER_THREADS);\n Matrix& dstMatrix = *new Matrix(pyTarget);\n for (int t = 0; t < NUM_JPEG_DECODER_THREADS; ++t) {\n int start_img = t * num_imgs_per_thread;\n int end_img = min(num_imgs, (t+1) * num_imgs_per_thread);\n\n threads[t] = new DecoderThread((PyObject*)pyJpegStrings, dstMatrix, start_img, end_img, img_size, inner_size, test, multiview);\n threads[t]->start();\n }\n\n for (int t = 0; t < NUM_JPEG_DECODER_THREADS; ++t) {\n threads[t]->join();\n delete threads[t];\n }\n assert(dstMatrix.isView());\n delete &dstMatrix;\n return Py_BuildValue(\"i\", 0);\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/reducepipeline.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \"../include/reducepipeline.cuh\"\n\nusing namespace std;\n\n/* =========================\n * IReducerSegment\n * =========================\n */\n// Null mat --> reducer on host\nIReduceSegment::IReduceSegment(IEightGPUReducer& parent, int deviceID, Queue* finishQueue)\n: _deviceID(deviceID), _next(NULL), _finishQueue(finishQueue), Thread(true, getDeviceCPUs(parent.getTgtDeviceID())) {\n}\n\nIReduceSegment::~IReduceSegment() {\n}\n\nNVMatrix& IReduceSegment::getChunk(const NVMatrix& mat, int chunkSize, int chunkIdx) {\n NVMatrix& line = mat.reshaped(1, mat.getNumElements());\n int start = chunkIdx * chunkSize;\n int end = min((chunkIdx+1) * chunkSize, mat.getNumElements());\n// _mat->printShape(\"_mat\");\n NVMatrix& chunk = line.sliceCols(start, end);\n delete &line;\n// chunk.printShape(\"chunk\");\n return chunk;\n}\n\nvoid* IReduceSegment::run() {\n bool exit = false;\n while (!exit) {\n ReduceMessage& msg = *_queue.dequeue();\n if (msg.getType() == EXIT) {\n exit = true;\n } else {\n bool term = processMessage(msg);\n if (term) {\n assert(_finishQueue);\n _finishQueue->enqueue(1);\n }\n }\n delete &msg;\n }\n return NULL;\n}\n\ninline NVMatrix& IReduceSegment::getMatrix(ReduceMessage& msg) {\n return msg.getMatrix(getDeviceID());\n}\n\nQueue& IReduceSegment::getQueue() {\n return _queue;\n}\n\ninline int IReduceSegment::getDeviceID() const {\n return _deviceID;\n}\n\nvoid IReduceSegment::addPrev(IReduceSegment& c) {\n _prev.push_back(&c);\n}\n\nvoid IReduceSegment::addNext(ReducePeer& c) {\n assert(_next == NULL);\n _next = &c;\n c.addPrev(*this);\n}\n\nbool IReduceSegment::isTerminal() const {\n return _next == NULL;\n}\n\n/* =========================\n * ReducerSource\n * =========================\n */\nReducerSource::ReducerSource(IEightGPUReducer& parent, int deviceID) : IReduceSegment(parent, deviceID, NULL) {\n}\n\nbool ReducerSource::processMessage(ReduceMessage& msg) {\n assert(msg.getType() == REDUCE_START);\n int numChunks = min(getMatrix(msg).getNumElements(), max(REDUCE_MIN_CHUNKS, min(REDUCE_MAX_CHUNKS, DIVUP(getMatrix(msg).getNumElements(), REDUCE_MIN_CHUNK_SIZE))));\n int chunkSize = DIVUP(getMatrix(msg).getNumElements(), numChunks);\n //printf(\"num chunks: %d\\n\", numChunks);\n for (int c = 0; c <= numChunks; ++c) {\n _next->getQueue().enqueue(new ReduceChunkMessage(*this, c, chunkSize, numChunks, msg.getScaleIntermediates(), msg.getScaleTarget(), msg.getMatrices()));\n }\n return false;\n}\n\n/* =========================\n * ReducerPeer\n * =========================\n */\nReducePeer::ReducePeer(IEightGPUReducer& parent,int deviceID, Queue* finishQueue) : IReduceSegment(parent, deviceID, finishQueue), _numInputsFinished(0) {\n _add = deviceID != DEVICE_HOST;\n}\n\nReducePeer::ReducePeer(IEightGPUReducer& parent) : IReduceSegment(parent, DEVICE_HOST, NULL), _numInputsFinished(0), _add(false) {\n}\n\nReducePeer::~ReducePeer() {\n for(std::map::iterator it = _streams.begin(); it != _streams.end(); ++it) {\n checkCudaErrors(cudaStreamDestroy(it->second));\n }\n _streams.clear();\n}\n\ninline cudaStream_t ReducePeer::getStream(int deviceID) {\n if (deviceID < 0) {\n return NULL;\n }\n if (_streams.count(deviceID) == 0) {\n NVMatrix::setDeviceID(deviceID);\n checkCudaErrors(cudaStreamCreateWithFlags(&_streams[deviceID], cudaStreamNonBlocking));\n }\n return _streams[deviceID];\n}\n\nbool ReducePeer::processMessage(ReduceMessage& msg) {\n assert(msg.getType() == REDUCE_CHUNK);\n\n ReduceChunkMessage& cmsg = *static_cast(&msg);\n// if (_numInputsReceived.count(cmsg.getChunkIdx()) == 0) {\n// _numInputsReceived[cmsg.getChunkIdx()] = 0;\n// }\n int& inputsRcvd = ++_numInputsReceived[cmsg.getChunkIdx()];\n// printf(\"reducer on device %d got msg chunk idx %d of %d, inputs rcvd for this chunk idx: %d/%d\\n\",\n// getDeviceID(), cmsg.getChunkIdx(), cmsg.getNumChunks(),_numInputsReceived[cmsg.getChunkIdx()], _prev.size());\n if (cmsg.getChunkIdx() < cmsg.getNumChunks()) {\n IReduceSegment& src = cmsg.getSource();\n float scalePrev = isTerminal() ? cmsg.getScaleIntermediates() : 1;\n float scaleSelf = inputsRcvd == 1 ? _add * (isTerminal() ? cmsg.getScaleTarget() : 1): 1;\n if (scaleSelf == 0 || isTerminal()) {\n if (getDeviceID() >= 0) {\n NVMatrix::setDeviceID(getDeviceID());\n }\n getMatrix(msg).resize(src.getMatrix(msg));\n }\n assert(getMatrix(msg).isSameDims(src.getMatrix(msg)));\n NVMatrix& prevChunk = getChunk(src.getMatrix(msg), cmsg.getChunkSize(), cmsg.getChunkIdx());\n NVMatrix& myChunk = getChunk(getMatrix(msg), cmsg.getChunkSize(), cmsg.getChunkIdx());\n int execDeviceID = getDeviceID() >= 0 ? getDeviceID() : src.getDeviceID();\n if (execDeviceID >= 0) {\n NVMatrix::setDeviceID(execDeviceID);\n prevChunk.add(myChunk, scalePrev, scaleSelf, myChunk, getStream(execDeviceID));\n NVMatrix::syncStream(getStream(execDeviceID));\n } else {\n assert(!isTerminal());\n hostAdd(prevChunk.getDevData(), myChunk.getDevData(), prevChunk.getNumElements(), scaleSelf);\n }\n\n delete &prevChunk;\n delete &myChunk;\n\n } else {\n _numInputsFinished++;\n }\n if (!isTerminal() && inputsRcvd == _prev.size()) {\n// printf(\" device %d enqueueing msg for next on device %d\\n\", getDeviceID(), _next->getDeviceID());\n _next->getQueue().enqueue(\n new ReduceChunkMessage(*this, cmsg.getChunkIdx(), cmsg.getChunkSize(), cmsg.getNumChunks(),\n cmsg.getScaleIntermediates(), cmsg.getScaleTarget(), cmsg.getMatrices()));\n }\n\n bool finished = _numInputsFinished == _prev.size();\n if (finished) {\n _numInputsFinished = 0;\n _numInputsReceived.clear();\n }\n return finished && isTerminal();\n}\n\nvoid ReducePeer::hostAdd(const float* src, float* tgt, const int n, const float scaleTgt) {\n if (scaleTgt != 0) {\n for (int i = 0; i < n; ++i) {\n tgt[i] = scaleTgt * tgt[i] + src[i];\n }\n } else {\n for (int i = 0; i < n; ++i) {\n tgt[i] = src[i];\n }\n }\n}\n\ninline NVMatrix& ReducePeer::getMatrix(ReduceMessage& msg) {\n if (getDeviceID() != DEVICE_HOST) {\n return IReduceSegment::getMatrix(msg);\n }\n return _mat;\n}\n\n/* =========================\n * EightGPUReducer\n * =========================\n */\nIEightGPUReducer::IEightGPUReducer(int tgtDeviceID) : _tgtDeviceID(tgtDeviceID) {\n}\n\nIEightGPUReducer::~IEightGPUReducer() {\n vector v;\n v.insert(v.end(), _sources.begin(), _sources.end());\n v.insert(v.end(), _peers.begin(), _peers.end());\n for (vector::iterator it = v.begin(); it != v.end(); ++it) {\n (*it)->getQueue().enqueue(new ReduceMessage(EXIT));\n (*it)->join();\n delete *it;\n }\n}\n\nIEightGPUReducer& IEightGPUReducer::construct() {\n vector same, other;\n for (int i = 0; i < 8; ++i) {\n if (i != _tgtDeviceID) {\n if (NVMatrix::canAccessPeer(_tgtDeviceID, i)) {\n same.insert(same.begin() + rand() % (1 + same.size()), i);\n } else {\n other.insert(other.begin() + rand() % (1 + other.size()), i);\n }\n }\n }\n assert(same.size() == 3);\n assert(other.size() == 4);\n makeConnections(same, other);\n for (vector::const_iterator it = _sources.begin(); it != _sources.end(); ++it) {\n (*it)->start();\n }\n for (vector::const_iterator it = _peers.begin(); it != _peers.end(); ++it) {\n (*it)->start();\n }\n return *this;\n}\n\nvoid IEightGPUReducer::reduce(std::map& mats, float scaleIntermediates, float scaleTarget) {\n assert(mats.size() == 8);\n // Check if source matrices are 0-sized\n bool zero = true;\n for (map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n if (it->first != _tgtDeviceID && it->second->getNumElements() != 0) {\n zero = false;\n break;\n }\n }\n if (zero) {\n mats[_tgtDeviceID]->resize(*mats[(_tgtDeviceID + 1) % 8]);\n } else {\n for (vector::const_iterator it = _sources.begin(); it != _sources.end(); ++it) {\n (*it)->getQueue().enqueue(new ReduceStartMessage(scaleIntermediates, scaleTarget, mats));\n }\n _finishQueue.dequeue();\n }\n assert(_finishQueue.getNumElements() == 0);\n}\n\nvoid IEightGPUReducer::reduce(std::map& mats, float scaleIntermediates) {\n reduce(mats, scaleIntermediates, 1);\n}\n\nvoid IEightGPUReducer::reduce(std::map& mats) {\n reduce(mats, 1, 1);\n}\n\nint IEightGPUReducer::getTgtDeviceID() const {\n return _tgtDeviceID;\n}\n\n/* =========================\n * EightGPUReducer1\n * =========================\n */\nEightGPUReducer1::EightGPUReducer1(int tgtDeviceID) : IEightGPUReducer(tgtDeviceID) {\n}\n\nvoid EightGPUReducer1::makeConnections(vector& same, vector&other) {\n // Setup segments on same truck\n _peers.push_back(new ReducePeer(*this, _tgtDeviceID, &_finishQueue)); // peers[0] = tgt\n _peers.push_back(new ReducePeer(*this,same[0], &_finishQueue)); // peers[1] = same truck 1\n _peers.push_back(new ReducePeer(*this,same[1], &_finishQueue)); // peers[2] = same truck 2\n _sources.push_back(new ReducerSource(*this,same[2])); // sources[0] = same truck 3\n \n _sources[0]->addNext(*_peers[2]);\n _peers[2]->addNext(*_peers[1]);\n _peers[1]->addNext(*_peers[0]);\n\n // Setup segments on other truck\n _sources.push_back(new ReducerSource(*this,other[0])); // sources[1] = other truck 1\n _peers.push_back(new ReducePeer(*this,other[1], &_finishQueue)); // peers[3] = other truck 2\n _peers.push_back(new ReducePeer(*this,other[2], &_finishQueue)); // peers[4] = other truck 3\n _sources.push_back(new ReducerSource(*this,other[3])); // sources[2] = other truck 4\n _peers.push_back(new ReducePeer(*this)); // peers[5] = host 1\n _peers.push_back(new ReducePeer(*this)); // peers[6] = host 2\n _peers.push_back(new ReducePeer(*this)); // peers[7] = host 3\n\n _sources[1]->addNext(*_peers[3]);\n _peers[3]->addNext(*_peers[5]);\n _peers[5]->addNext(*_peers[7]);\n _peers[7]->addNext(*_peers[0]);\n _peers[4]->addNext(*_peers[6]);\n _peers[6]->addNext(*_peers[7]);\n _sources[2]->addNext(*_peers[4]);\n}\n\n/* =========================\n * EightGPUReducer2\n * =========================\n */\nEightGPUReducer2::EightGPUReducer2(int tgtDeviceID) : IEightGPUReducer(tgtDeviceID) {\n}\n\nvoid EightGPUReducer2::makeConnections(vector& same, vector&other) {\n // Setup segments on same truck\n _peers.push_back(new ReducePeer(*this,_tgtDeviceID, &_finishQueue)); // peers[0] = tgt\n _peers.push_back(new ReducePeer(*this,same[0], &_finishQueue)); // peers[1] = same truck 1\n _peers.push_back(new ReducePeer(*this,same[1], &_finishQueue)); // peers[2] = same truck 2\n _sources.push_back(new ReducerSource(*this,same[2])); // sources[0] = same truck 3\n\n _sources[0]->addNext(*_peers[2]);\n _peers[2]->addNext(*_peers[1]);\n _peers[1]->addNext(*_peers[0]);\n\n // Setup segments on other truck\n _sources.push_back(new ReducerSource(*this,other[0])); // sources[1] = other truck 1\n _peers.push_back(new ReducePeer(*this,other[1], &_finishQueue)); // peers[3] = other truck 2\n _peers.push_back(new ReducePeer(*this,other[2], &_finishQueue)); // peers[4] = other truck 3\n _peers.push_back(new ReducePeer(*this,other[3], &_finishQueue)); // peers[5] = other truck 4\n _peers.push_back(new ReducePeer(*this)); // peers[6] = host 1\n\n _sources[1]->addNext(*_peers[3]);\n _peers[3]->addNext(*_peers[4]);\n _peers[4]->addNext(*_peers[5]);\n _peers[5]->addNext(*_peers[6]);\n _peers[6]->addNext(*_peers[0]);\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/streambroadcast.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/streambroadcast.cuh\"\n\nusing namespace std;\n\n/*\n * =====================\n * StreamBroadcast\n * =====================\n */\n\nStreamBroadcast::StreamBroadcast(map& streams) {\n _streams = streams;\n}\n\nStreamBroadcast::StreamBroadcast() {\n}\n\nvoid StreamBroadcast::toHostMem(NVMatrix& src, NVMatrix& hostmem, int srcDevice) {\n src.copy(hostmem, _streams[srcDevice]);\n}\n\nvoid StreamBroadcast::toTarget(NVMatrix& hostmem, NVMatrix& tgt, int tgtDevice, float scaleTarget, float scaleOutput) {\n tgt.add(hostmem, scaleTarget, scaleOutput, tgt, _streams[tgtDevice]);\n}\n\nvoid StreamBroadcast::init(map& mats) {\n for (map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n if (_streams.count(it->first) == 0) {\n _ownedStreams.insert(it->first);\n NVMatrix::setDeviceID(it->first);\n checkCudaErrors(cudaStreamCreateWithFlags(&_streams[it->first], cudaStreamNonBlocking));\n }\n }\n}\n\nStreamBroadcast::~StreamBroadcast() {\n for (set::const_iterator it = _ownedStreams.begin(); it != _ownedStreams.end(); ++it) {\n checkCudaErrors(cudaStreamDestroy(_streams[*it]));\n }\n}\n\ncudaStream_t StreamBroadcast::getStream(int deviceID) {\n return _streams[deviceID];\n}\n\n// Sync stream associated with given device id\nvoid StreamBroadcast::sync(int deviceID) {\n NVMatrix::syncStream(_streams[deviceID]);\n}\n\nvoid StreamBroadcast::transfer(map& mats, int srcDevice) {\n transfer(mats, _hostMem, srcDevice, 0, 1);\n}\n\nvoid StreamBroadcast::transfer(map& mats, int srcDevice, float scaleTarget, float scaleOutput) {\n transfer(mats, _hostMem, srcDevice, scaleTarget, scaleOutput);\n}\n\nvoid StreamBroadcast::transfer(map& mats, HostNVMatrix& hostbuf, int srcDevice, float scaleTarget, float scaleOutput) {\n int oldDeviceID = NVMatrix::getDeviceID();\n assert(mats.count(srcDevice) != 0);\n init(mats);\n// assert(_streams.count(srcDevice) != 0);\n if (mats.size() > 1) {\n if (mats[srcDevice]->getNumElements() == 0) {\n for (map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n it->second->resize(*mats[srcDevice]);\n }\n } else {\n int tgtDevice = mats.begin()->first != srcDevice ? mats.begin()->first : (++mats.begin())->first;\n // This case is a simple copy\n if (mats.size() == 2 && NVMatrix::canAccessPeer(tgtDevice, srcDevice)) {\n NVMatrix::setDeviceID(tgtDevice);\n mats[tgtDevice]->add(*mats[srcDevice], scaleTarget, scaleOutput, *mats[tgtDevice], _streams[tgtDevice]);\n } else {\n NVMatrix& src = *mats[srcDevice];\n if (hostbuf.getNumElements() < src.getNumElements()) {\n hostbuf.resize(1,src.getNumElements());\n }\n hostbuf.setTrans(src.isTrans());\n\n NVMatrix& hostmat = hostbuf.sliceCols(0, src.getNumElements());\n assert(hostmat.isView());\n hostmat.reshape(src.getNumRows(), src.getNumCols());\n\n for (map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n assert(it->second->isContiguous());\n NVMatrix::setDeviceID(it->first);\n it->second->resize(src);\n assert(it->second->isTrans() == src.isTrans());\n }\n int numChunks = min(DIVUP(src.getNumElements(), SB_MIN_CHUNK_SIZE), SB_MAX_CHUNKS);\n\n if (numChunks == 1) { // This is a bit faster for small matrices\n NVMatrix::setDeviceID(srcDevice);\n toHostMem(src, hostmat, srcDevice);\n NVMatrix::syncStream(_streams[srcDevice]);\n\n for (map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n if (it->first != src.getDataDeviceID()) {\n NVMatrix::setDeviceID(it->first);\n toTarget(hostmat, *it->second, it->first, scaleTarget, scaleOutput);\n }\n }\n } else {\n int n = src.getNumElements();\n\n map lines;\n for (map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n lines[it->first] = &it->second->reshaped(1, n);\n lines[it->first]->setTrans(src.isTrans());\n }\n NVMatrix& srcLine = *lines[srcDevice];\n hostmat.reshape(1, n);\n\n int chunkSize = DIVUP(n, numChunks);\n bool trans = src.isTrans();\n for (int i = 0; i < numChunks; ++i) {\n int start = i * chunkSize;\n int end = min((i+1) * chunkSize, n);\n if (start < end) {\n NVMatrix& tmpSrc = srcLine.sliceCols(start, end); // view\n NVMatrix& tmpHostmem = hostmat.sliceCols(start, end); // view\n\n NVMatrix::setDeviceID(srcDevice);\n toHostMem(tmpSrc, tmpHostmem, srcDevice);\n NVMatrix::syncStream(_streams[srcDevice]);\n\n for (map::const_iterator it = lines.begin(); it != lines.end(); ++it) {\n if (it->first != srcDevice) {\n NVMatrix& tmpTgt = it->second->sliceCols(start, end); // view\n NVMatrix::setDeviceID(it->first);\n toTarget(tmpHostmem, tmpTgt, it->first, scaleTarget, scaleOutput);\n delete &tmpTgt;\n }\n }\n delete &tmpSrc;\n delete &tmpHostmem;\n }\n }\n for (map::const_iterator it = lines.begin(); it != lines.end(); ++it) {\n delete it->second;\n }\n }\n delete &hostmat;\n }\n for(map::const_iterator it = mats.begin(); it != mats.end(); ++it) {\n if (it->first != srcDevice) {\n NVMatrix::syncStream(_streams[it->first]);\n }\n }\n }\n }\n if (oldDeviceID >= 0) {\n NVMatrix::setDeviceID(oldDeviceID);\n }\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/util.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n#include \"../include/util.cuh\"\n\nusing namespace std;\n\nstringv* getStringV(PyObject* pyList) {\n if (pyList == NULL) {\n return NULL;\n }\n stringv* vec = new stringv(); \n for (int i = 0; i < PyList_GET_SIZE(pyList); i++) {\n vec->push_back(std::string(PyString_AS_STRING(PyList_GET_ITEM(pyList, i))));\n }\n return vec;\n}\n\nfloatv* getFloatV(PyObject* pyList) {\n if (pyList == NULL) {\n return NULL;\n }\n floatv* vec = new floatv(); \n for (int i = 0; i < PyList_GET_SIZE(pyList); i++) {\n vec->push_back(PyFloat_AS_DOUBLE(PyList_GET_ITEM(pyList, i)));\n }\n return vec;\n}\n\nintv* getIntV(PyObject* pyList) {\n if (pyList == NULL) {\n return NULL;\n }\n intv* vec = new intv(); \n for (int i = 0; i < PyList_GET_SIZE(pyList); i++) {\n vec->push_back(PyInt_AS_LONG(PyList_GET_ITEM(pyList, i)));\n }\n return vec;\n}\n\nint* getIntA(PyObject* pyList) {\n if (pyList == NULL) {\n return NULL;\n }\n int* arr = new int[PyList_GET_SIZE(pyList)];\n for (int i = 0; i < PyList_GET_SIZE(pyList); i++) {\n arr[i] = PyInt_AS_LONG(PyList_GET_ITEM(pyList, i));\n }\n return arr;\n}\n\nMatrixV* getMatrixV(PyObject* pyList) {\n return getMatrixV(pyList, PyList_GET_SIZE(pyList));\n}\n\nMatrixV* getMatrixV(PyObject* pyList, int len) {\n if (pyList == NULL) {\n return NULL;\n }\n MatrixV* vec = new MatrixV(); \n for (int i = 0; i < len; i++) {\n vec->push_back(new Matrix((PyArrayObject*)PyList_GET_ITEM(pyList, i)));\n }\n return vec;\n}\n\nPyObjectV* pyDictGetValues(PyObject* dict) {\n PyObjectV* pov = new PyObjectV();\n PyObject* valuesList = PyDict_Values(dict);\n int numValues = PyList_GET_SIZE(valuesList);\n\n for (int i = 0; i < numValues; i++) {\n pov->push_back(PyList_GET_ITEM(valuesList, i));\n }\n Py_DECREF(valuesList);\n return pov;\n}\n\nint pyDictGetInt(PyObject* dict, const char* key) {\n return PyInt_AS_LONG(PyDict_GetItemString(dict, key));\n}\n\nintv* pyDictGetIntV(PyObject* dict, const char* key) {\n return getIntV(PyDict_GetItemString(dict, key));\n}\n\nint* pyDictGetIntA(PyObject* dict, const char* key) {\n return getIntA(PyDict_GetItemString(dict, key));\n}\n\nstd::string pyDictGetString(PyObject* dict, const char* key) {\n return std::string(PyString_AS_STRING(PyDict_GetItemString(dict, key)));\n}\n\nfloat pyDictGetFloat(PyObject* dict, const char* key) {\n return PyFloat_AS_DOUBLE(PyDict_GetItemString(dict, key));\n}\n\nfloatv* pyDictGetFloatV(PyObject* dict, const char* key) {\n return getFloatV(PyDict_GetItemString(dict, key));\n}\n\nMatrix* pyDictGetMatrix(PyObject* dict, const char* key) {\n return new Matrix((PyArrayObject*)PyDict_GetItemString(dict, key));\n}\n\nMatrixV* pyDictGetMatrixV(PyObject* dict, const char* key) {\n return getMatrixV(PyDict_GetItemString(dict, key));\n}\n\nstringv* pyDictGetStringV(PyObject* dict, const char* key) {\n return getStringV(PyDict_GetItemString(dict, key));\n}\n\nbool pyDictHasKey(PyObject* dict, const char* key) {\n PyObject* str = PyString_FromString(key);\n bool b = PyDict_Contains(dict, str);\n Py_DECREF(str);\n return b;\n}\n\ntemplate\nvoid shuffleVector(vector& v, int start, int end) {\n const int len = end - start;\n for (int i = 0; i < len*5; ++i) {\n int r1 = start + rand() % len;\n int r2 = start + rand() % len;\n int tmp = v[r1];\n v[r1] = v[r2];\n v[r2] = tmp;\n }\n}\n\ntemplate\nstd::string tostr(T n) {\n ostringstream result;\n result << n;\n return result.str();\n}\n\ntemplate\nvoid deleteElements(vector& v) {\n deleteElements(v, false);\n}\n\ntemplate\nvoid deleteElements(vector& v, bool deleteContainer) {\n for (typename vector::const_iterator it = v.begin(); it != v.end(); ++it) {\n delete *it;\n }\n if (deleteContainer) {\n delete &v;\n }\n}\n\nstatic Lock deviceCPULock;\nstatic std::map > deviceCPUs;\n\nstd::vector& getDeviceCPUs(int deviceID) {\n deviceCPULock.acquire();\n if (deviceCPUs.count(deviceID) == 0 && deviceID >= 0) {\n struct cudaDeviceProp props;\n checkCudaErrors(cudaGetDeviceProperties(&props, deviceID));\n char pciString[13];\n\n sprintf(pciString, \"%04x\", props.pciDomainID);\n pciString[4] = ':';\n sprintf(pciString + 5, \"%02x\", props.pciBusID);\n pciString[7] = ':';\n sprintf(pciString + 8, \"%02x\", props.pciDeviceID);\n pciString[10] = '.';\n pciString[11] = '0';\n pciString[12] = 0;\n std::string path = std::string(\"/sys/bus/pci/devices/\") + std::string(pciString) + \"/local_cpulist\";\n ifstream f(path.c_str());\n\n if (f.is_open()) {\n std::string cpuString;\n while (getline(f, cpuString, ',')) {\n int start, end;\n int found = sscanf(cpuString.c_str(), \"%d-%d\", &start, &end);\n end = found == 1 ? start : end;\n if (found > 0) {\n for (int i = start; i <= end; ++i) {\n deviceCPUs[deviceID].push_back(i);\n }\n } \n }\n f.close();\n } else {\n printf(\"Unable to open %s\\n\", path.c_str());\n }\n }\n vector& ret = deviceCPUs[deviceID];\n deviceCPULock.release();\n return ret;\n}\n\ntemplate void shuffleVector(std::vector& v, int start, int end);\ntemplate std::string tostr(int n);\ntemplate void deleteElements(std::vector& v, bool deleteContainer);\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/weights.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \"../include/weights.cuh\"\n#include \"../include/lr.cuh\"\n#include \"../include/worker.cuh\"\n\nusing namespace std;\n\n/* ========================\n * IWeightReducer\n * ========================\n */\nint IWeightReducer::getDeviceID() {\n return _replicas[_tgtReplicaID]->getDeviceID();\n}\n\nIWeightReducer::IWeightReducer(std::map& replicas, int tgtReplicaID) : _replicas(replicas), _tgtReplicaID(tgtReplicaID) {\n}\n\nIWeightReducer::~IWeightReducer() {\n}\n\nIWeightReducer& IWeightReducer::make(std::map& replicas, int tgtReplicaID) {\n if (replicas.size() == 8) {\n return *new ParallelWeightReducer(replicas, tgtReplicaID);\n }\n return *new SequentialWeightReducer(replicas, tgtReplicaID);\n}\n\n/* ========================\n * SequentialWeightReducer\n * ========================\n */\nSequentialWeightReducer::SequentialWeightReducer(std::map& replicas, int tgtReplicaID) : IWeightReducer(replicas, tgtReplicaID) {\n _sb = new StreamBroadcast();\n}\n\nSequentialWeightReducer::~SequentialWeightReducer() {\n delete _sb;\n}\n\nvoid SequentialWeightReducer::reduce(std::map gradShards, float gradScale, bool toInc) {\n std::map mats; // device id -> grad\n mats[getDeviceID()] = toInc ? &_replicas[_tgtReplicaID]->getInc() : &_replicas[_tgtReplicaID]->getGrad();\n for (int i = 0, r = _tgtReplicaID; i < _replicas.size(); ++i, r = (r + 1) % _replicas.size()) {\n if (r != _tgtReplicaID) {\n mats[_replicas[r]->getDeviceID()] = gradShards[r];\n _sb->transfer(mats, _replicas[r]->getDeviceID(), 1, gradScale);\n mats.erase(_replicas[r]->getDeviceID());\n }\n }\n}\n\n/* ========================\n * ParallelWeightReducer\n * ========================\n */\nParallelWeightReducer::ParallelWeightReducer(std::map& replicas, int tgtReplicaID) : IWeightReducer(replicas, tgtReplicaID) {\n _reducer = &(new EightGPUReducer1(getDeviceID()))->construct();\n}\n\nParallelWeightReducer::~ParallelWeightReducer() {\n delete _reducer;\n}\n\nvoid ParallelWeightReducer::reduce(std::map gradShards, float gradScale, bool toInc) {\n std::map mats; // device id -> grad\n mats[getDeviceID()] = toInc ? &_replicas[_tgtReplicaID]->getInc() : &_replicas[_tgtReplicaID]->getGrad();\n for (std::map::const_iterator it = _replicas.begin(); it != _replicas.end(); ++it) {\n if (it->first != _tgtReplicaID) {\n mats[it->second->getDeviceID()] = gradShards[it->first];\n }\n }\n _reducer->reduce(mats, gradScale, 1);\n}\n\n// weights has pointer to layer, layer pointer to thread\n// thread has sync (copy) object for every other thread\n// weights uses copy object to sum grad contributions into inc matrix slice (phase 1)\n// weights broadcasts inc matrix slice to other inc matrix replicas (phase 2)\n\nNVMatrix& Weights::operator*() const {\n return getW();\n}\n\n/*\n * TODO: get rid of this constructor duplication.\n */\nWeights::Weights(Weights& srcWeights, ParameterSchedule& lrs, Layer& parent) {\n init(srcWeights.getCPUW(), srcWeights.getCPUWInc(), lrs, parent, 0, 0, srcWeights.getMom(), srcWeights.isUseGrad(), false);\n _srcWeights = &srcWeights;\n}\n\nWeights::Weights(Matrix& hWeights, Matrix& hWeightsInc, ParameterSchedule& lrs, Layer& parent, float wc,\n float wball, float mom, bool useGrad) {\n init(hWeights, hWeightsInc, lrs, parent, wc, wball, mom, useGrad, true);\n}\n\nvoid Weights::init(Matrix& hWeights, Matrix& hWeightsInc, ParameterSchedule& lrs, Layer& parent, float wc,\n float wball, float mom, bool useGrad, bool cleanup) {\n _srcWeights = NULL;\n _hWeights = &hWeights;\n _hWeightsInc = &hWeightsInc;\n _numUpdates = 0;\n _lrs = &lrs;\n _parent = &parent;\n _wc = wc;\n _wball = wball;\n _mom = mom;\n _useGrad = useGrad;\n _onGPU = false;\n _weights = NULL;\n _weightsInc = NULL;\n _weightsGrad = NULL;\n _cleanup = cleanup;\n _reducer = NULL;\n _broadcaster = NULL;\n}\n\nWeights::~Weights() {\n\tdelete _lrs;\n\tdelete _reducer;\n\tdelete _broadcaster;\n if (_cleanup) {\n delete _hWeights;\n delete _hWeightsInc;\n if (_srcWeights == NULL) {\n delete _weights;\n delete _weightsInc;\n delete _weightsGrad;\n }\n }\n}\n\nNVMatrix& Weights::getW() const {\n assert(_onGPU);\n return *_weights;\n}\n\nNVMatrix& Weights::getInc() const {\n assert(_onGPU);\n return *_weightsInc;\n}\n\n/*\n * TODO: This seems like pretty nasty behavior, I should change this.\n */\nNVMatrix& Weights::getGrad() const {\n assert(_onGPU);\n return _useGrad ? *_weightsGrad : *_weightsInc;\n}\n\nMatrix& Weights::getCPUW() const {\n return *_hWeights;\n}\n\nMatrix& Weights::getCPUWInc() const {\n return *_hWeightsInc;\n}\n\nint Weights::getNumRows() const {\n return _hWeights->getNumRows();\n}\n\nint Weights::getNumCols() const {\n return _hWeights->getNumCols();\n}\n\nmap& Weights::getReplicas() {\n return _replicas;\n}\n\ntemplate T& Weights::getShard(T& mat, int replicaID) {\n const int n = mat.getNumElements();\n T& line = mat.reshaped(1, n);\n const int shardStart = min(n, replicaID * _shardSize);\n const int shardEnd = min(n, (replicaID + 1) * _shardSize);\n T& slice = line.sliceCols(shardStart, shardEnd);\n assert(slice.isView());\n delete &line;\n return slice;\n}\n\ntemplate T& Weights::getShard(T& mat) {\n return getShard(mat, getReplicaID());\n}\n\nISafeBroadcastNetwork& Weights::getBroadcaster() {\n if (_broadcaster == NULL) {\n set devices;\n for (map::const_iterator it = _replicas.begin(); it != _replicas.end(); ++it) {\n devices.insert(it->second->getDeviceID());\n }\n // NOTE: we must use safe broadcaster becasue we want to *add* our value to everyone else\n _broadcaster = &ISafeBroadcastNetwork::make(devices, getDeviceID()); //&(new NaiveBroadcaster(devices, getDeviceID()))->construct();\n }\n return *_broadcaster;\n}\n\nIWeightReducer& Weights::getReducer() {\n if (_reducer == NULL) {\n _reducer = &IWeightReducer::make(_replicas, getReplicaID());\n }\n return *_reducer;\n}\n\nvoid Weights::copyToCPU() {\n if (_srcWeights == NULL) {\n assert(_onGPU);\n NVMatrix::syncStream(); // for safety\n if (getReplicaID() == 0) {\n _weights->copyToHost(*_hWeights);\n\n // Synchronize weights amongst replicas while we're at it.\n map weights;\n for (map::const_iterator it = _replicas.begin(); it != _replicas.end(); ++it) {\n weights[it->second->getDeviceID()] = &it->second->getW();\n }\n // These things sync before returning.\n getBroadcaster().broadcast(weights, 1, 0);\n }\n if (_useGrad) {\n Matrix& hIncShard = getShard(*_hWeightsInc);\n _weightsInc->copyToHost(hIncShard);\n delete &hIncShard;\n } else { // In this case there's definitely only one replica\n _weightsInc->copyToHost(*_hWeightsInc);\n }\n }\n}\n\n// This function is assumed to be called in the order in which the layers\n// were defined\nvoid Weights::copyToGPU() {\n assert(!_onGPU);\n // Copies are performed on the default (computation) stream, so that's fine.\n if (_srcWeights == NULL) {\n _weights = _weights == NULL ? new NVMatrix() : _weights;\n _weightsInc = _weightsInc == NULL ? new NVMatrix() : _weightsInc;\n _weights->copyFromHost(*_hWeights, true);\n\n if (_useGrad) {\n // In this case there is no need to store the entire inc matrix.\n // Just this replica's shard (for synchronization purposes) will do.\n Matrix& hIncShard = getShard(*_hWeightsInc);\n _weightsInc->copyFromHost(hIncShard, true);\n delete &hIncShard;\n } else {\n _weightsInc->copyFromHost(*_hWeightsInc, true);\n }\n\n _weightsGrad = _useGrad ? (_weightsGrad == NULL ? new NVMatrix(*_weights) : _weightsGrad) : NULL;\n } else {\n _weights = _srcWeights->_weights;\n _weightsInc = _srcWeights->_weightsInc;\n _weightsGrad = _srcWeights->_weightsGrad;\n }\n _onGPU = true;\n}\n\nvoid Weights::aggregateReplicaGradients(float progress) {\n map gradShards;\n map wShards;\n for (map::const_iterator it = _replicas.begin(); it != _replicas.end(); ++it) {\n gradShards[it->first] = &getShard(it->second->getGrad(), getReplicaID());\n wShards[it->first] = &getShard(it->second->getW(), getReplicaID());\n assert(wShards[it->first]->isContiguous() && gradShards[it->first]->isContiguous());\n }\n\n float gradScale = _lrs->getValue(progress);\n NVMatrix::setDeviceID(getDeviceID());\n\n if (_wc > 0) {\n NVMatrixTernaryOps::WeightedAdd wadd = NVMatrixTernaryOps::WeightedAdd(_mom, gradScale, -_wc * _lrs->getValue(progress));\n _weightsInc->applyTernary(wadd, *gradShards[getReplicaID()], *wShards[getReplicaID()], *_weightsInc);\n } else {\n _weightsInc->add(*gradShards[getReplicaID()], _mom, gradScale);\n }\n\n // Reduce everyone's gradient into my inc shard\n NVMatrix::syncStream(); // Crucial since the reducer does everything in its own streams!!\n getReducer().reduce(gradShards, gradScale, true);\n\n // Broadcast my inc -> all replicas\n map mats; // device id -> grad\n mats[getDeviceID()] = _weightsInc;\n for (map::const_iterator it = _replicas.begin(); it != _replicas.end(); ++it) {\n if (it->first != getReplicaID()) {\n mats[it->second->getDeviceID()] = wShards[it->first];\n }\n }\n getBroadcaster().broadcast(mats, 1, 1);\n\n NVMatrix::setDeviceID(getDeviceID());\n wShards[getReplicaID()]->add(*_weightsInc);\n\n // Cleanup\n for (map::const_iterator it = _replicas.begin(); it != _replicas.end(); ++it) {\n delete gradShards[it->first];\n delete wShards[it->first];\n }\n}\n\n\n// When _useGrad is false, weightsInc is assumed to contain the \n// entire, properly scaled weight increment.\n// OTHERWISE, scale your gradient by 1 / numCases only.\n// The scaling by epsW will be done in this routine.\nvoid Weights::update(float progress) {\n // Only true owner of weights updates\n// printf(\"%s update weights\\n\", _parent->getName().c_str());\n if (_srcWeights == NULL && _lrs->getBaseValue() > 0) {\n assert(_onGPU);\n if (_useGrad) {\n aggregateReplicaGradients(progress);\n } else { // Definitely no replicas in this case\n if (_wc > 0) {\n _weightsInc->add(*_weights, -_wc * _lrs->getValue(progress));\n }\n _weights->add(*_weightsInc);\n }\n _numUpdates = 0;\n }\n}\n\nint Weights::incNumUpdates() {\n if (_srcWeights != NULL) {\n return _srcWeights->incNumUpdates();\n }\n return _numUpdates++;\n}\n\n// Returns the number of times a gradient has been computed for this\n// weight matrix during the current pass (interval between two calls of update())\n// through the net. This number will only be greater than 1 if this weight matrix\n// is *shared* by multiple layers in the net.\nint Weights::getNumUpdates() const {\n if (_srcWeights != NULL) {\n return _srcWeights->getNumUpdates();\n }\n return _numUpdates;\n}\n\nfloat Weights::getEps(float progress) const {\n return _lrs->getValue(progress);\n}\n\nfloat Weights::getMom() const {\n return _mom;\n}\n\nfloat Weights::getWC() const {\n return _wc;\n}\n\nfloat Weights::getWBall() const {\n return _wball;\n}\n\nbool Weights::isUseGrad() const { // is good grammar\n return _useGrad;\n}\n\nbool Weights::isOwner() const {\n return _srcWeights == NULL;\n}\n\nParameterSchedule& Weights::getLearningRateSchedule() const {\n\treturn *_lrs;\n}\n\nvoid Weights::addReplica(Weights& replica) {\n _replicas[replica.getReplicaID()] = &replica;\n\n const int n = _hWeights->getNumElements();\n _shardSize = DIVUP(n, _replicas.size());\n}\n\nint Weights::getReplicaID() {\n return _parent->getReplicaID();\n}\n\nint Weights::getDeviceID() {\n return _parent->getDeviceID();\n}\n\nLayer& Weights::getParent() {\n return *_parent;\n}\n\n/* \n * ===============\n * WeightList\n * ===============\n */\nWeights& WeightList::operator[](const int i) const {\n return *_weightList[i];\n}\n\nWeights& WeightList::at(const int i) const {\n return *_weightList[i];\n}\n\nWeightList::~WeightList() {\n for (int i = 0; i < _weightList.size(); i++) {\n delete _weightList[i];\n }\n}\n\nWeightList::WeightList() {\n}\n\nvoid WeightList::addWeights(Weights& w) {\n _weightList.push_back(&w);\n}\n\n\nvoid WeightList::update(float progress) {\n for (int i = 0; i < getSize(); i++) {\n _weightList[i]->update(progress);\n }\n}\n\nvoid WeightList::copyToCPU() {\n for (int i = 0; i < getSize(); i++) {\n _weightList[i]->copyToCPU();\n }\n}\n\nvoid WeightList::copyToGPU() {\n for (int i = 0; i < getSize(); i++) {\n _weightList[i]->copyToGPU();\n }\n}\n\nint WeightList::getSize() const {\n return _weightList.size();\n}\n\nvoid WeightList::addReplica(WeightList& replica) {\n for (int i = 0; i < getSize(); i++) {\n _weightList[i]->addReplica(replica[i]);\n }\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/cudaconvnet/src/worker.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \"../include/util.cuh\"\n#include \"../include/worker.cuh\"\n#include \"../include/timer.cuh\"\n\nusing namespace std;\n\n/* \n * ====================\n * WorkResult\n * ====================\n */\nWorkResult::WorkResult(WorkResult::RESULTS resultType, Cost& results) : _resultType(resultType), _results(&results) {\n}\n\nWorkResult::WorkResult(WorkResult::RESULTS resultType) : _resultType(resultType), _results(NULL) {\n}\n\nWorkResult::~WorkResult() {\n delete _results; // delete NULL is ok\n}\n\nCost& WorkResult::getResults() const {\n return *_results;\n}\n\nWorkResult::RESULTS WorkResult::getResultType() const {\n return _resultType;\n}\n\n/* \n * ====================\n * Worker\n * ====================\n */\nWorker::Worker(ConvNet& convNet) : _convNet(&convNet) {\n}\n\nWorker::~Worker() {\n}\n\n/* \n * ====================\n * DataWorker\n * ====================\n */\nDataWorker::DataWorker(ConvNet& convNet, CPUData& data) : Worker(convNet), _data(&data), _dp(NULL) {\n assert(_data != NULL);\n}\n\nbool DataWorker::run() {\n _dp = &_convNet->getDataProvider();\n _dp->setData(*_data);\n _run();\n _dp->clearData();\n return false;\n}\n\nDataWorker::~DataWorker() {\n}\n\n/* \n * ====================\n * TrainingWorker\n * ====================\n */\nTrainingWorker::TrainingWorker(ConvNet& convNet, CPUData& data, double progress, bool test)\n : DataWorker(convNet, data), _progress(progress), _test(test) {\n}\n\nvoid TrainingWorker::_run() {\n _convNet->setTrainingProgress(_progress);\n Cost& batchCost = *new Cost();\n int numMinibatches = _dp->getNumMinibatches();\n for (int i = 0; i < numMinibatches; i++) {\n for (int p = 0; p < _convNet->getNumPasses(); p++) {\n _convNet->fprop(i, p, _test ? PASS_TEST : PASS_TRAIN);\n _convNet->getCost(batchCost);\n\n if (!_test) {\n _convNet->bprop(p, PASS_TRAIN);\n _convNet->updateWeights(p);\n }\n }\n }\n _convNet->getResultQueue().enqueue(new WorkResult(WorkResult::BATCH_DONE, batchCost));\n}\n\n/*\n * ====================\n * SyncWorker\n * ====================\n */\nSyncWorker::SyncWorker(ConvNet& convNet) : Worker(convNet) {\n}\n\nbool SyncWorker::run() {\n _convNet->copyToCPU();\n _convNet->getResultQueue().enqueue(new WorkResult(WorkResult::SYNC_DONE));\n return false;\n}\n\n/*\n * ====================\n * ExitWorker\n * ====================\n */\nExitWorker::ExitWorker(ConvNet& convNet) : Worker(convNet) {\n}\n\nbool ExitWorker::run() {\n return true;\n}\n\n/* \n * ====================\n * GradCheckWorker\n * ====================\n */\nGradCheckWorker::GradCheckWorker(ConvNet& convNet, CPUData& data) \n : DataWorker(convNet, data) {\n}\n\nvoid GradCheckWorker::_run() {\n _convNet->checkGradients();\n exit(0); // eh\n}\n\n/* \n * ====================\n * MultiviewTestWorker\n * ====================\n */\nMultiviewTestWorker::MultiviewTestWorker(ConvNet& convNet, CPUData& data, int numViews, Matrix& cpuProbs, const char* logregName) \n : DataWorker(convNet, data), _numViews(numViews), _cpuProbs(&cpuProbs), _logregName(logregName) {\n// assert(_data->getNumCases() % _numViews == 0);\n// assert(convNet.getNumReplicas() == 1); // For now?\n}\n\nMultiviewTestWorker::MultiviewTestWorker(ConvNet& convNet, CPUData& data, int numViews) \n : DataWorker(convNet, data), _numViews(numViews), _cpuProbs(NULL), _logregName(\"\") {\n// assert(_data->getNumCases() % _numViews == 0);\n}\n\nMultiviewTestWorker::~MultiviewTestWorker() {\n// delete _cpuProbs;\n}\n\nCPUData& MultiviewTestWorker::getMinibatch(int v, int i) {\n int numCasesPerView = _dp->getNumCases() / _numViews;\n int miniStart = v * numCasesPerView + i * _dp->getMinibatchSize();\n int miniEnd = v * numCasesPerView + min(numCasesPerView, (i + 1) * _dp->getMinibatchSize());\n CPUData& mini = _dp->getDataSlice(miniStart, miniEnd);\n return mini;\n}\n\nvoid MultiviewTestWorker::_run() {\n int numCasesPerView = _dp->getNumCases() / _numViews;\n int numMiniPerView = DIVUP(numCasesPerView, _dp->getMinibatchSize());\n\n Cost& batchCost = *new Cost();\n for (int i = 0; i < numMiniPerView; i++) {\n for (int v = 0; v < _numViews - 1; v++) {\n for (int p = 0; p < _convNet->getNumPasses(); p++) {\n _convNet->fprop(getMinibatch(v, i), p, v == 0 ? PASS_MULTIVIEW_TEST_START : PASS_MULTIVIEW_TEST);\n }\n }\n for (int p = 0; p < _convNet->getNumPasses(); p++) {\n _convNet->fprop(getMinibatch(_numViews - 1, i), p, PASS_MULTIVIEW_TEST_END);\n _convNet->getCost(batchCost);\n }\n// if (_cpuProbs != NULL) {\n// LogregCostLayer& logregLayer = *dynamic_cast(&_convNet->getLayer(_logregName, 0));\n// NVMatrix::setDeviceID(logregLayer.getDeviceID());\n// Matrix& miniProbs = _cpuProbs->sliceRows(i * _dp->getMinibatchSize(),\n// min(numCasesReal, (i + 1) * _dp->getMinibatchSize()));\n// NVMatrix& acts = logregLayer.getProbsAccum();\n// NVMatrix acts_T;\n// acts.transpose(acts_T);\n// acts_T.copyToHost(miniProbs);\n//\n// delete &miniProbs;\n// }\n }\n _convNet->getResultQueue().enqueue(new WorkResult(WorkResult::BATCH_DONE, batchCost));\n}\n\n/* \n * ====================\n * FeatureWorker\n * ====================\n */\nFeatureWorker::FeatureWorker(ConvNet& convNet, CPUData& data, MatrixV& ftrs, stringv& layerNames, bool deleteFeatures)\n : DataWorker(convNet, data), _ftrs(&ftrs), _layerNames(&layerNames), _deleteFeatures(deleteFeatures) {\n assert(layerNames.size() == ftrs.size());\n for (int i = 0; i < layerNames.size(); i++) {\n assert(ftrs[i]->getNumRows() == data.getNumCases());\n assert(!ftrs[i]->isTrans());\n }\n}\n\nFeatureWorker::~FeatureWorker() {\n if (_deleteFeatures) {\n for (int i = 0; i < _ftrs->size(); i++) {\n delete _ftrs->at(i);\n }\n delete _ftrs;\n }\n delete _layerNames;\n}\n\nvoid FeatureWorker::_run() {\n Cost& batchCost = *new Cost();\n map repStart; // Feature write start offsets within minibatch\n for (int i = 0; i < _dp->getNumMinibatches(); i++) {\n for (int f = 0; f < _layerNames->size(); f++) {\n repStart[f] = 0;\n }\n\n for (int p = 0; p < _convNet->getNumPasses(); p++) {\n _convNet->fprop(i, p, PASS_FEATURE_GEN);\n _convNet->getCost(batchCost);\n for (int f = 0; f < _layerNames->size(); f++) {\n\n if (_convNet->getLayer(_layerNames->at(f), 0).getFwdActiveInputReplicaIdx(p) >= 0) {\n Matrix& miniFtrs = _ftrs->at(f)->sliceRows(i * _dp->getMinibatchSize(),\n min(_dp->getNumCases(), (i + 1) * _dp->getMinibatchSize()));\n\n for (int r = 0; r < _convNet->getLayer(_layerNames->at(f), 0).getNumReplicas(); ++r) {\n Layer& ftrLayer = _convNet->getLayer(_layerNames->at(f), r);\n int d = ftrLayer.getDeviceID();\n NVMatrix::setDeviceID(d);\n NVMatrix& acts = ftrLayer.getActs();\n\n Matrix& repMiniFtrs = miniFtrs.sliceRows(repStart[f],\n min(int(miniFtrs.getNumRows()), repStart[f] + acts.getLeadingDim()));\n\n NVMatrix acts_T;\n acts.transpose(false);\n acts.transpose(acts_T);\n acts_T.copyToHost(repMiniFtrs);\n NVMatrix::syncStream(); // eh why not\n\n delete &repMiniFtrs;\n\n repStart[f] += acts.getLeadingDim();\n }\n delete &miniFtrs;\n }\n }\n }\n }\n _convNet->getResultQueue().enqueue(new WorkResult(WorkResult::BATCH_DONE, batchCost));\n}\n\n/* \n * ====================\n * DataGradWorker\n * ====================\n */\nDataGradWorker::DataGradWorker(ConvNet& convNet, CPUData& data, Matrix& dataGrads, int dataLayerIdx, int softmaxLayerIdx)\n : DataWorker(convNet, data), _dataGrads(&dataGrads), _dataLayerIdx(dataLayerIdx), _softmaxLayerIdx(softmaxLayerIdx) {\n// assert(dataGrads.getNumRows() == data.getNumCases());\n// assert(!dataGrads.isTrans());\n}\n\nDataGradWorker::~DataGradWorker() {\n// delete _dataGrads;\n}\n\nvoid DataGradWorker::_run() {\n// DataLayer& dataLayer = *dynamic_cast(&_convNet->getLayer(_dataLayerIdx));\n// SoftmaxLayer& softmaxLayer = *dynamic_cast(&_convNet->getLayer(_softmaxLayerIdx));\n// softmaxLayer.setDoLogregGrad(false);\n// Cost& batchCost = *new Cost(0);\n// for (int i = 0; i < _dp->getNumMinibatches(); i++) {\n// _convNet->fprop(i, PASS_TEST);\n// _convNet->getCost(batchCost);\n// softmaxLayer.getActs().apply(NVMatrixOps::Log(), softmaxLayer.getActsGrad());\n// \n// softmaxLayer.getActsGrad().addScalar(1);\n// softmaxLayer.getActsGrad().scale(-1);\n// softmaxLayer.incRcvdBInputs();\n// softmaxLayer.bprop(PASS_TEST);\n// \n// Matrix& miniDataGrads = _dataGrads->sliceRows(i * _dp->getMinibatchSize(),\n// min(_dp->getNumCases(), (i + 1) * _dp->getMinibatchSize()));\n// NVMatrix& grads = dataLayer.getActsGrad();\n// NVMatrix grads_T;\n// if (grads.isTrans()) {\n// NVMatrix& soft_T = grads.getTranspose();\n// soft_T.transpose(grads_T);\n// delete &soft_T;\n// } else {\n// grads.transpose(grads_T);\n// }\n// grads_T.copyToHost(miniDataGrads);\n// delete &miniDataGrads;\n// \n// _convNet->reset();\n// }\n// cudaThreadSynchronize();\n// _convNet->getResultQueue().enqueue(new WorkResult(WorkResult::BATCH_DONE, batchCost));\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/initw.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom python_util.gpumodel import *\nimport numpy as n\nimport numpy.random as nr\n\ndef get_src(filename):\n src = IGPUModel.load_checkpoint(filename)\n return src['model_state']['layers']\n \n# Initialize weight matrix by copying weight matrix of given layer\ndef makew(name, idx, shape, params):\n src = get_src(params[0])\n return src[name]['weights'][idx]\n \n# Initialize bias vector by copying bias vector of given layer\ndef makeb(name, shape, params):\n src = get_src(params[0])\n return src[name]['biases']\n \ndef concat(shape, src, src_layers, src_func):\n mat = n.empty(shape, dtype=n.single, order='F')\n start = 0\n for s in src_layers:\n m = src_func(src[s])\n mat[:,start:start+m.shape[1]] = m\n start += m.shape[1]\n return mat\n\n# Initialize weight matrix by concatenating weight matrices of given layers\ndef makewcat(name, idx, shape, params):\n src, src_layers = get_src(params[0]), params[1:]\n return concat(shape, src, src_layers, lambda x: x['weights'][idx])\n \n# Initialize bias vector by concatenating bias vectors of given layers\ndef makebcat(name, shape, params):\n src, src_layers = get_src(params[0]), params[1:]\n return concat(shape, src, src_layers, lambda x: x['biases'])\n\n# Initialize bias vector from tuple input\ndef makeb_vec(name, shape, params):\n return n.array([n.single(x) for x in params], dtype=n.single).reshape((1, len(params)))\n" }, { "path": "caffe2/contrib/cuda-convnet2/layer.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom math import exp\nimport sys\nimport ConfigParser as cfg\nimport os\nimport numpy as n\nimport numpy.random as nr\nfrom math import ceil, floor\nfrom collections import OrderedDict\nfrom os import linesep as NL\nfrom python_util.options import OptionsParser\nimport re\n\nclass LayerParsingError(Exception):\n pass\n\n# A neuron that doesn't take parameters\nclass NeuronParser:\n def __init__(self, type, func_str, uses_acts=True, uses_inputs=True):\n self.type = type\n self.func_str = func_str\n self.uses_acts = uses_acts \n self.uses_inputs = uses_inputs\n \n def parse(self, type):\n if type == self.type:\n return {'type': self.type,\n 'params': {},\n 'usesActs': self.uses_acts,\n 'usesInputs': self.uses_inputs}\n return None\n \n# A neuron that takes parameters\nclass ParamNeuronParser(NeuronParser):\n neuron_regex = re.compile(r'^\\s*(\\w+)\\s*\\[\\s*(\\w+(\\s*,\\w+)*)\\s*\\]\\s*$')\n def __init__(self, type, func_str, uses_acts=True, uses_inputs=True):\n NeuronParser.__init__(self, type, func_str, uses_acts, uses_inputs)\n m = self.neuron_regex.match(type)\n self.base_type = m.group(1)\n self.param_names = m.group(2).split(',')\n assert len(set(self.param_names)) == len(self.param_names)\n \n def parse(self, type):\n m = re.match(r'^%s\\s*\\[([\\d,\\.\\s\\-]*)\\]\\s*$' % self.base_type, type)\n if m:\n try:\n param_vals = [float(v.strip()) for v in m.group(1).split(',')]\n if len(param_vals) == len(self.param_names):\n return {'type': self.base_type,\n 'params': dict(zip(self.param_names, param_vals)),\n 'usesActs': self.uses_acts,\n 'usesInputs': self.uses_inputs}\n except TypeError:\n pass\n return None\n\nclass AbsTanhNeuronParser(ParamNeuronParser):\n def __init__(self):\n ParamNeuronParser.__init__(self, 'abstanh[a,b]', 'f(x) = a * |tanh(b * x)|')\n \n def parse(self, type):\n dic = ParamNeuronParser.parse(self, type)\n # Make b positive, since abs(tanh(bx)) = abs(tanh(-bx)) and the C++ code\n # assumes b is positive.\n if dic:\n dic['params']['b'] = abs(dic['params']['b'])\n return dic\n\nclass ParamParser:\n lrs_regex = re.compile(r'^\\s*(\\w+)\\s*(?:\\[\\s*(\\w+(\\s*;\\w+)*)\\s*\\])?\\s*$')\n param_converters = {'i': int,\n 'f': float}\n def __init__(self, type):\n m = self.lrs_regex.match(type)\n self.base_type = m.group(1)\n param_names_with_type = m.group(2).split(';') if m.group(2) is not None else []\n self.param_names = [p[1:] for p in param_names_with_type]\n self.param_types = [self.param_converters[p[0]] for p in param_names_with_type]\n self.param_regex_inner = \";\".join([('\\s*%s\\s*=\\s*[^;,\\s=]+\\s*' % p) for p in self.param_names])\n self.regex_str = ('^%s\\s*(?:\\[(%s)\\])?\\s*$') % (self.base_type, self.param_regex_inner)\n assert len(set(self.param_names)) == len(self.param_names)\n \n def parse(self, type):\n m = re.match(self.regex_str, type, flags=re.IGNORECASE)\n if m:\n try:\n param_vals = [ptype(v.split('=')[1].strip()) for ptype,v in zip(self.param_types, m.group(1).split(';'))] if m.group(1) is not None else []\n if len(param_vals) == len(self.param_names):\n return {'type': self.base_type,\n 'params': dict(zip(self.param_names, param_vals))}\n except TypeError:\n pass\n return None\n\n# Subclass that throws more convnet-specific exceptions than the default\nclass MyConfigParser(cfg.SafeConfigParser):\n def safe_get(self, section, option, f=cfg.SafeConfigParser.get, typestr=None, default=None):\n try:\n return f(self, section, option)\n except cfg.NoOptionError, e:\n if default is not None:\n return default\n raise LayerParsingError(\"Layer '%s': required parameter '%s' missing\" % (section, option))\n except ValueError, e:\n if typestr is None:\n raise e\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be %s\" % (section, option, typestr))\n \n def safe_get_list(self, section, option, f=str, typestr='strings', default=None):\n v = self.safe_get(section, option, default=default)\n if type(v) == list:\n return v\n try:\n return [f(x.strip()) for x in v.split(',')]\n except:\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be ','-delimited list of %s\" % (section, option, typestr))\n \n def safe_get_int(self, section, option, default=None):\n return self.safe_get(section, option, f=cfg.SafeConfigParser.getint, typestr='int', default=default)\n \n def safe_get_float(self, section, option, default=None):\n return self.safe_get(section, option, f=cfg.SafeConfigParser.getfloat, typestr='float', default=default)\n \n def safe_get_bool(self, section, option, default=None):\n return self.safe_get(section, option, f=cfg.SafeConfigParser.getboolean, typestr='bool', default=default)\n \n def safe_get_float_list(self, section, option, default=None):\n return self.safe_get_list(section, option, float, typestr='floats', default=default)\n \n def safe_get_int_list(self, section, option, default=None):\n return self.safe_get_list(section, option, int, typestr='ints', default=default)\n \n def safe_get_bool_list(self, section, option, default=None):\n return self.safe_get_list(section, option, lambda x: x.lower() in ('true', '1'), typestr='bools', default=default)\n\n# A class that implements part of the interface of MyConfigParser\nclass FakeConfigParser(object):\n def __init__(self, dic):\n self.dic = dic\n\n def safe_get(self, section, option, default=None):\n if option in self.dic:\n return self.dic[option]\n return default\n \n def safe_get_int(self, section, option, default=None):\n return int(self.safe_get(section, option, default))\n \n def safe_get_int_list(self, section, option, default=None):\n return list(self.safe_get(section, option, default))\n\nclass LayerParser:\n def __init__(self):\n self.dic = {}\n self.set_defaults()\n \n # Post-processing step -- this is called after all layers have been initialized\n def optimize(self, layers):\n self.dic['actsTarget'] = -1\n self.dic['actsGradTarget'] = -1\n if len(set(len(l['gpu']) for l in layers.values() if 'inputs' in l and self.dic['name'] in l['inputs'])) > 1:\n# print set(len(l['gpu']) for l in layers.values())\n raise LayerParsingError(\"Layer '%s': all next layers must have equal number of replicas.\" % (self.dic['name']))\n \n def parse_params(self, vals, parsers, param_name, human_name, num_params=1):\n dic, name = self.dic, self.dic['name']\n \n# print vals\n if len(vals) != num_params and len(vals) != 1:\n raise LayerParsingError(\"Layer '%s': expected list of length %d for %s but got list of length %d.\"% (name, num_params, param_name, len(vals)))\n parsed = []\n# print vals\n for v in vals:\n for p in parsers:\n parsedv = p.parse(v)\n if parsedv: \n parsed += [parsedv]\n break\n if len(parsed) == 1 and num_params > 1:\n parsed = parsed * num_params\n if len(parsed) == num_params:\n return parsed\n# print parsed, vals\n raise LayerParsingError(\"Layer '%s': unable to parse %s %s=%s.\" % (name, human_name, param_name, \",\".join(vals)))\n \n # Add parameters from layer parameter file\n def add_params(self, mcp):\n pass\n# self.dic['conserveMem'] = mcp.convnet.op.get_value('conserve_mem') if mcp.convnet is not None else 0\n \n def init(self, dic):\n self.dic = dic\n return self\n \n def set_defaults(self):\n self.dic['outputs'] = 0\n self.dic['parser'] = self\n self.dic['requiresParams'] = False\n # Does this layer use its own activity matrix\n # for some purpose other than computing its output?\n # Usually, this will only be true for layers that require their\n # own activity matrix for gradient computations. For example, layers\n # with logistic units must compute the gradient y * (1 - y), where y is \n # the activity matrix.\n # \n # Layers that do not not use their own activity matrix should advertise\n # this, since this will enable memory-saving matrix re-use optimizations.\n #\n # The default value of this property is True, for safety purposes.\n # If a layer advertises that it does not use its own activity matrix when\n # in fact it does, bad things will happen.\n self.dic['usesActs'] = True\n \n # Does this layer use the activity matrices of its input layers\n # for some purpose other than computing its output?\n #\n # Again true by default for safety\n self.dic['usesInputs'] = True\n \n # Force this layer to use its own activity gradient matrix,\n # instead of borrowing one from one of its inputs.\n # \n # This should be true for layers where the mapping from output\n # gradient to input gradient is non-elementwise.\n self.dic['forceOwnActs'] = True\n \n # Does this layer need the gradient at all?\n # Should only be true for layers with parameters (weights).\n self.dic['gradConsumer'] = False\n \n # The gpu indices on which this layer runs\n self.dic['gpu'] = [-1]\n \n def parse(self, name, mcp, prev_layers, model=None):\n self.prev_layers = prev_layers\n self.dic['name'] = name\n self.dic['type'] = mcp.safe_get(name, 'type')\n self.dic['id'] = len(prev_layers)\n\n return self.dic \n\n def verify_float_range(self, v, param_name, _min, _max):\n self.verify_num_range(v, param_name, _min, _max, strconv=lambda x: '%.3f' % x)\n\n def verify_num_range(self, v, param_name, _min, _max, strconv=lambda x:'%d' % x):\n if type(v) == list:\n for i,vv in enumerate(v):\n self._verify_num_range(vv, param_name, _min, _max, i, strconv=strconv)\n else:\n self._verify_num_range(v, param_name, _min, _max, strconv=strconv)\n \n def _verify_num_range(self, v, param_name, _min, _max, input=-1, strconv=lambda x:'%d' % x):\n layer_name = self.dic['name'] if input < 0 else '%s[%d]' % (self.dic['name'], input)\n if _min is not None and _max is not None and (v < _min or v > _max):\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be in the range %s-%s\" % (layer_name, param_name, strconv(_min), strconv(_max)))\n elif _min is not None and v < _min:\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be greater than or equal to %s\" % (layer_name, param_name, strconv(_min)))\n elif _max is not None and v > _max:\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be smaller than or equal to %s\" % (layer_name, param_name, strconv(_max)))\n \n def verify_divisible(self, value, div, value_name, div_name=None, input_idx=0):\n layer_name = self.dic['name'] if len(self.dic['inputs']) == 0 else '%s[%d]' % (self.dic['name'], input_idx)\n if value % div != 0:\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be divisible by %s\" % (layer_name, value_name, str(div) if div_name is None else \"'%s'\" % div_name))\n \n def verify_str_in(self, value, param_name, lst, input_idx=-1):\n lname = self.dic['name'] if input_idx == -1 else ('%s[%d]' % (self.dic['name'], input_idx))\n if value not in lst:\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be one of %s\" % (lname, param_name, \", \".join(\"'%s'\" % s for s in lst)))\n \n def verify_int_in(self, value, param_name, lst):\n if value not in lst:\n raise LayerParsingError(\"Layer '%s': parameter '%s' must be one of %s\" % (self.dic['name'], param_name, \", \".join(\"'%d'\" % s for s in lst)))\n \n def verify_all_ints_in(self, values, param_name, lst):\n if len([v for v in values if v not in lst]) > 0:\n raise LayerParsingError(\"Layer '%s': all parameters to '%s' must be among %s\" % (self.dic['name'], param_name, \", \".join(\"'%d'\" % s for s in lst)))\n \n def verify_input_dims(self, dims):\n for i,d in enumerate(dims):\n if d is not None and self.dic['numInputs'][i] != d: # first input must be labels\n raise LayerParsingError(\"Layer '%s': dimensionality of input %d must be %d\" % (self.dic['name'], i, d))\n\n # This looks for neuron=x arguments in various layers, and creates\n # separate layer definitions for them.\n @staticmethod\n def detach_neuron_layers(layers):\n for name,l in layers.items():\n if l['type'] != 'neuron' and 'neuron' in l and l['neuron']:\n NeuronLayerParser().detach_neuron_layer(name, layers)\n \n @staticmethod\n def parse_layers(layer_cfg_path, param_cfg_path, model, layers={}):\n try:\n if not os.path.exists(layer_cfg_path):\n raise LayerParsingError(\"Layer definition file '%s' does not exist\" % layer_cfg_path)\n if not os.path.exists(param_cfg_path):\n raise LayerParsingError(\"Layer parameter file '%s' does not exist\" % param_cfg_path)\n if len(layers) == 0:\n mcp = MyConfigParser(dict_type=OrderedDict)\n mcp.readfp(open(layer_cfg_path))\n for name in mcp.sections():\n if not mcp.has_option(name, 'type'):\n raise LayerParsingError(\"Layer '%s': no type given\" % name)\n ltype = mcp.safe_get(name, 'type')\n if ltype not in layer_parsers:\n raise LayerParsingError(\"Layer '%s': Unknown layer type: '%s'\" % (name, ltype))\n layers[name] = layer_parsers[ltype]().parse(name, mcp, layers, model)\n \n LayerParser.detach_neuron_layers(layers)\n for l in layers.values():\n l['parser'].optimize(layers)\n del l['parser']\n \n for name,l in layers.items():\n if not l['type'].startswith('cost.'):\n found = max(name in l2['inputs'] for l2 in layers.values() if 'inputs' in l2)\n if not found:\n raise LayerParsingError(\"Layer '%s' of type '%s' is unused\" % (name, l['type']))\n \n mcp = MyConfigParser(dict_type=OrderedDict)\n mcp.readfp(open(param_cfg_path))\n# mcp.convnet = model\n for name,l in layers.items():\n if not mcp.has_section(name) and l['requiresParams']:\n raise LayerParsingError(\"Layer '%s' of type '%s' requires extra parameters, but none given in file '%s'.\" % (name, l['type'], param_cfg_path))\n lp = layer_parsers[l['type']]().init(l)\n lp.add_params(mcp)\n except LayerParsingError, e:\n print e\n sys.exit(1)\n return layers\n \n @staticmethod\n def register_layer_parser(ltype, cls):\n if ltype in layer_parsers:\n raise LayerParsingError(\"Layer type '%s' already registered\" % ltype)\n layer_parsers[ltype] = cls\n\n# Any layer that takes an input (i.e. non-data layer)\nclass LayerWithInputParser(LayerParser):\n def __init__(self, num_inputs=-1):\n LayerParser.__init__(self)\n self.num_inputs = num_inputs\n \n def verify_num_params(self, params, auto_expand=True):\n for param in params:\n if len(self.dic[param]) != len(self.dic['inputs']):\n if auto_expand and len(self.dic[param]) == 1:\n self.dic[param] *= len(self.dic['inputs'])\n else:\n raise LayerParsingError(\"Layer '%s': %s list length does not match number of inputs\" % (self.dic['name'], param)) \n \n # layers: dictionary: name -> layer\n def optimize(self, layers):\n LayerParser.optimize(self, layers)\n dic = self.dic\n \n # Check if I have an input that no one else uses.\n #print \"Layer %s optimizing\" % dic['name']\n if not dic['forceOwnActs']:\n for i, inp in enumerate(dic['inputLayers']):\n if inp['outputs'] == dic['outputs'] and sum(('inputs' in ll) and (inp['name'] in ll['inputs']) for ll in layers.itervalues()) == 1:\n # I can share my activity matrix with this layer\n # if it does not use its activity matrix, and I \n # do not need to remember my inputs.\n # TODO: a dropout layer should always be able to overwrite\n # its input. Make it so.\n# print \"Layer %s(uses inputs=%d), input %s(uses acts = %d)\" % (dic['name'], dic['usesInputs'], inp['name'], inp['usesActs'])\n if not inp['usesActs'] and not dic['usesInputs']:\n dic['actsTarget'] = i\n print \"Layer %s using acts from layer %s\" % (dic['name'], inp['name'])\n# print \"Layer '%s' sharing activity matrix with layer '%s'\" % (dic['name'], l['name'])\n # I can share my gradient matrix with this layer if we're on the same GPU.\n # This is different from the logic for actsTarget because this guy doesn't\n # have an actsGrad matrix on my GPU if our GPUs are different, so there's\n # nothing to share.\n if dic['gpu'] == inp['gpu']:\n dic['actsGradTarget'] = i\n# print \"Layer '%s' sharing activity gradient matrix with layer '%s'\" % (dic['name'], l['name'])\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerParser.parse(self, name, mcp, prev_layers, model)\n \n dic['inputs'] = [inp.strip() for inp in mcp.safe_get(name, 'inputs').split(',')]\n \n for inp in dic['inputs']:\n if inp not in prev_layers:\n raise LayerParsingError(\"Layer '%s': input layer '%s' not defined\" % (name, inp))\n \n dic['inputLayers'] = [prev_layers[inp] for inp in dic['inputs']]\n dic['gpu'] = mcp.safe_get_int_list(name, 'gpu', default=dic['inputLayers'][0]['gpu'])\n dic['gpus'] = \", \".join('%s' % d for d in dic['gpu'])\n dic['numReplicas'] = len(dic['gpu'])\n \n if len(set(dic['gpu'])) != len(dic['gpu']):\n raise LayerParsingError(\"Layer '%s': all replicas must run on different GPUs.\" % (name))\n \n for inp in dic['inputs']:\n # Data layers do not explicitly define how many replicas they have.\n # The number of replicas for a data layer is given by the number of replicas\n # in the next layer(s). So we set that here.\n inpl = prev_layers[inp]\n if inpl['type'] == 'data':\n inpl['numReplicas'] = dic['numReplicas']\n if inpl['numReplicas'] % dic['numReplicas'] != 0:\n raise LayerParsingError(\"Layer '%s': number of replicas (%d) must divide number of replicas in all input layers (input %s has %d replicas).\" % (name, dic['numReplicas'], inpl['name'], inpl['numReplicas']))\n if len(set(inp['numReplicas'] for inp in dic['inputLayers'])) != 1:\n raise LayerParsingError(\"Layer '%s': all input layers must have equal numbers of replicas.\" % (name))\n\n # Need to also assert that all *next* layers have equal number of replicas but this is hard so it's done in Layer.optimize\n for inp in dic['inputLayers']:\n if inp['outputs'] == 0:\n raise LayerParsingError(\"Layer '%s': input layer '%s' does not produce any output\" % (name, inp['name']))\n dic['numInputs'] = [inp['outputs'] for inp in dic['inputLayers']]\n \n # Layers can declare a neuron activation function to apply to their output, as a shortcut\n # to avoid declaring a separate neuron layer above themselves.\n dic['neuron'] = mcp.safe_get(name, 'neuron', default=\"\")\n if self.num_inputs > 0 and len(dic['numInputs']) != self.num_inputs:\n raise LayerParsingError(\"Layer '%s': number of inputs must be %d\" % (name, self.num_inputs))\n \n if model:\n self.verify_all_ints_in(dic['gpu'], 'gpu', range(len(model.op.get_value('gpu'))))\n return dic\n \n def verify_img_size(self):\n dic = self.dic\n if dic['numInputs'][0] % dic['imgPixels'] != 0 or dic['imgSize'] * dic['imgSize'] != dic['imgPixels']:\n raise LayerParsingError(\"Layer '%s': has %-d dimensional input, not interpretable as %d-channel images\" % (dic['name'], dic['numInputs'][0], dic['channels']))\n \n @staticmethod\n def grad_consumers_below(dic):\n if dic['gradConsumer']:\n return True\n if 'inputLayers' in dic:\n return any(LayerWithInputParser.grad_consumers_below(l) for l in dic['inputLayers'])\n \n def verify_no_grads(self):\n if LayerWithInputParser.grad_consumers_below(self.dic):\n raise LayerParsingError(\"Layer '%s': layers of type '%s' cannot propagate gradient and must not be placed over layers with parameters.\" % (self.dic['name'], self.dic['type']))\n\nclass NailbedLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['forceOwnActs'] = False\n dic['usesActs'] = False\n dic['usesInputs'] = False\n \n dic['channels'] = mcp.safe_get_int(name, 'channels')\n dic['stride'] = mcp.safe_get_int(name, 'stride')\n\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n \n # Computed values\n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n dic['outputsX'] = (dic['imgSize'] + dic['stride'] - 1) / dic['stride']\n dic['start'] = (dic['imgSize'] - dic['stride'] * (dic['outputsX'] - 1)) / 2\n dic['outputs'] = dic['channels'] * dic['outputsX']**2\n \n self.verify_num_range(dic['outputsX'], 'outputsX', 0, None)\n \n self.verify_img_size()\n \n print \"Initialized bed-of-nails layer '%s' on GPUs %s, producing %dx%d %d-channel output\" % (name, dic['gpus'], dic['outputsX'], dic['outputsX'], dic['channels'])\n return dic\n \nclass GaussianBlurLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['forceOwnActs'] = False\n dic['usesActs'] = False\n dic['usesInputs'] = False\n dic['outputs'] = dic['numInputs'][0]\n \n dic['channels'] = mcp.safe_get_int(name, 'channels')\n dic['filterSize'] = mcp.safe_get_int(name, 'filterSize')\n dic['stdev'] = mcp.safe_get_float(name, 'stdev')\n\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n self.verify_int_in(dic['filterSize'], 'filterSize', [3, 5, 7, 9])\n \n # Computed values\n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n dic['filter'] = n.array([exp(-(dic['filterSize']/2 - i)**2 / float(2 * dic['stdev']**2)) \n for i in xrange(dic['filterSize'])], dtype=n.float32).reshape(1, dic['filterSize'])\n dic['filter'] /= dic['filter'].sum()\n self.verify_img_size()\n \n if dic['filterSize'] > dic['imgSize']:\n raise LayerParsingError(\"Later '%s': filter size (%d) must be smaller than image size (%d).\" % (dic['name'], dic['filterSize'], dic['imgSize']))\n \n print \"Initialized Gaussian blur layer '%s', producing %dx%d %d-channel output\" % (name, dic['imgSize'], dic['imgSize'], dic['channels'])\n \n return dic\n \nclass HorizontalReflectionLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['outputs'] = dic['numInputs'][0]\n dic['channels'] = mcp.safe_get_int(name, 'channels')\n \n self.verify_num_range(dic['channels'], 'channels', 1, 3)\n\n # Computed values\n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n self.verify_img_size()\n \n print \"Initialized horizontal reflection layer '%s', producing %dx%d %d-channel output\" % (name, dic['imgSize'], dic['imgSize'], dic['channels'])\n \n return dic\n \nclass ResizeLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['forceOwnActs'] = False\n dic['usesActs'] = False\n dic['usesInputs'] = False\n \n dic['channels'] = mcp.safe_get_int(name, 'channels')\n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n \n dic['scale'] = mcp.safe_get_float(name, 'scale')\n dic['tgtSize'] = int(floor(dic['imgSize'] / dic['scale']))\n dic['tgtPixels'] = dic['tgtSize']**2\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n # Really not recommended to use this for such severe scalings\n self.verify_float_range(dic['scale'], 'scale', 0.5, 2) \n\n dic['outputs'] = dic['channels'] * dic['tgtPixels']\n \n self.verify_img_size()\n self.verify_no_grads()\n \n print \"Initialized resize layer '%s', producing %dx%d %d-channel output\" % (name, dic['tgtSize'], dic['tgtSize'], dic['channels'])\n \n return dic\n \nclass RandomScaleLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['forceOwnActs'] = False\n dic['usesActs'] = False\n dic['usesInputs'] = False\n \n dic['channels'] = mcp.safe_get_int(name, 'channels')\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n \n # Computed values\n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n \n dic['maxScale'] = mcp.safe_get_float(name, 'maxScale')\n dic['tgtSize'] = mcp.safe_get_int(name, 'tgtSize')\n min_size = int(floor(dic['imgSize'] / dic['maxScale']))\n max_size = dic['imgSize'] #int(floor(dic['imgSize'] * dic['maxScale']))\n if dic['tgtSize'] < min_size:\n raise LayerParsingError(\"Layer '%s': target size must be greater than minimum image size after rescaling (%d)\" % (name, min_size))\n if dic['tgtSize'] > max_size:\n raise LayerParsingError(\"Layer '%s': target size must be smaller than maximum image size after rescaling (%d)\" % (name, max_size))\n dic['tgtPixels'] = dic['tgtSize']**2\n \n self.verify_float_range(dic['maxScale'], 'maxScale', 1, 2) \n\n dic['outputs'] = dic['channels'] * dic['tgtPixels']\n \n self.verify_img_size()\n self.verify_no_grads()\n \n print \"Initialized random scale layer '%s', producing %dx%d %d-channel output\" % (name, dic['tgtSize'], dic['tgtSize'], dic['channels'])\n \n return dic\n \nclass CropLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['forceOwnActs'] = False\n dic['usesActs'] = False\n dic['usesInputs'] = False\n \n dic['channels'] = mcp.safe_get_int(name, 'channels')\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n dic['startX'] = mcp.safe_get_int(name, 'startX')\n dic['startY'] = mcp.safe_get_int(name, 'startY', default=dic['startX'])\n dic['sizeX'] = mcp.safe_get_int(name, 'sizeX')\n \n # Computed values\n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n \n dic['outputs'] = dic['channels'] * (dic['sizeX']**2)\n \n self.verify_num_range(dic['startX'], 'startX', 0, dic['imgSize']-1)\n self.verify_num_range(dic['sizeX'], 'sizeX', 1, dic['imgSize'])\n self.verify_num_range(dic['startY'], 'startY', 0, dic['imgSize']-1)\n self.verify_img_size()\n self.verify_no_grads()\n \n if dic['startX'] + dic['sizeX'] > dic['imgSize']:\n raise LayerParsingError(\"Layer '%s': startX (%d) + sizeX (%d) > imgSize (%d)\" % (name, dic['startX'], dic['sizeX'], dic['imgSize']))\n \n print \"Initialized cropping layer '%s', producing %dx%d %d-channel output\" % (name, dic['sizeX'], dic['sizeX'], dic['channels'])\n \n return dic\n \nclass ColorTransformLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['forceOwnActs'] = False\n dic['usesActs'] = False\n dic['usesInputs'] = False\n\n # Computed values\n dic['imgPixels'] = dic['numInputs'][0] / 3\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n dic['channels'] = 3\n dic['outputs'] = dic['numInputs'][0]\n \n self.verify_img_size()\n self.verify_no_grads()\n \n return dic\n \nclass RGBToYUVLayerParser(ColorTransformLayerParser):\n def __init__(self):\n ColorTransformLayerParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = ColorTransformLayerParser.parse(self, name, mcp, prev_layers, model)\n print \"Initialized RGB --> YUV layer '%s', producing %dx%d %d-channel output\" % (name, dic['imgSize'], dic['imgSize'], dic['channels'])\n return dic\n \nclass RGBToLABLayerParser(ColorTransformLayerParser):\n def __init__(self):\n ColorTransformLayerParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = ColorTransformLayerParser.parse(self, name, mcp, prev_layers, model)\n dic['center'] = mcp.safe_get_bool(name, 'center', default=False)\n print \"Initialized RGB --> LAB layer '%s', producing %dx%d %d-channel output\" % (name, dic['imgSize'], dic['imgSize'], dic['channels'])\n return dic\n\nclass NeuronLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n @staticmethod\n def get_unused_layer_name(layers, wish):\n if wish not in layers:\n return wish\n for i in xrange(1, 100):\n name = '%s.%d' % (wish, i)\n if name not in layers:\n return name\n raise LayerParsingError(\"This is insane.\")\n \n def parse_neuron(self, neuron_str):\n for n in neuron_parsers:\n p = n.parse(neuron_str)\n if p: # Successfully parsed neuron, return it\n self.dic['neuron'] = p\n self.dic['usesActs'] = self.dic['neuron']['usesActs']\n self.dic['usesInputs'] = self.dic['neuron']['usesInputs']\n \n return\n # Could not parse neuron\n # Print available neuron types\n colnames = ['Neuron type', 'Function']\n m = max(len(colnames[0]), OptionsParser._longest_value(neuron_parsers, key=lambda x:x.type)) + 2\n ntypes = [OptionsParser._bold(colnames[0].ljust(m))] + [n.type.ljust(m) for n in neuron_parsers]\n fnames = [OptionsParser._bold(colnames[1])] + [n.func_str for n in neuron_parsers]\n usage_lines = NL.join(ntype + fname for ntype,fname in zip(ntypes, fnames))\n \n raise LayerParsingError(\"Layer '%s': unable to parse neuron type '%s'. Valid neuron types: %sWhere neurons have parameters, they must be floats.\" % (self.dic['name'], neuron_str, NL + usage_lines + NL))\n \n def detach_neuron_layer(self, src_name, layers):\n dic = self.dic\n# self.set_defaults()\n dic['name'] = NeuronLayerParser.get_unused_layer_name(layers, '%s_neuron' % src_name)\n dic['type'] = 'neuron'\n dic['inputs'] = src_name\n dic['neuron'] = layers[src_name]['neuron']\n dic['gpu'] = layers[src_name]['gpu']\n \n # Yes it's not entirely correct to pass all of layers as prev_layers, but it's harmless\n dic = self.parse(dic['name'], FakeConfigParser(dic), layers)\n dic['src_layer'] = src_name\n \n # Link upper layers to this new one\n for l in layers.values():\n if 'inputs' in l:\n l['inputs'] = [inp if inp != src_name else dic['name'] for inp in l['inputs']]\n l['inputLayers'] = [inp if inp['name'] != src_name else dic for inp in l['inputLayers']]\n layers[dic['name']] = dic\n \n def parse(self, name, mcp, prev_layers, model=None):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['outputs'] = dic['numInputs'][0]\n self.parse_neuron(dic['neuron'])\n dic['forceOwnActs'] = False\n print \"Initialized neuron layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n\nclass EltwiseSumLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self)\n \n def add_params(self, mcp):\n LayerWithInputParser.add_params(self, mcp)\n dic, name = self.dic, self.dic['name']\n dic['coeffs'] = mcp.safe_get_float_list(name, 'coeffs', default=[1.0] * len(dic['inputs']))\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n \n if len(set(dic['numInputs'])) != 1:\n raise LayerParsingError(\"Layer '%s': all inputs must have the same dimensionality. Got dimensionalities: %s\" % (name, \", \".join(str(s) for s in dic['numInputs'])))\n dic['outputs'] = dic['numInputs'][0]\n dic['usesInputs'] = False\n dic['usesActs'] = False\n dic['forceOwnActs'] = False\n dic['requiresParams'] = True \n \n print \"Initialized elementwise sum layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n \nclass EltwiseMaxLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n if len(dic['inputs']) < 2:\n raise LayerParsingError(\"Layer '%s': elementwise max layer must have at least 2 inputs, got %d.\" % (name, len(dic['inputs'])))\n if len(set(dic['numInputs'])) != 1:\n raise LayerParsingError(\"Layer '%s': all inputs must have the same dimensionality. Got dimensionalities: %s\" % (name, \", \".join(str(s) for s in dic['numInputs'])))\n dic['outputs'] = dic['numInputs'][0]\n\n print \"Initialized elementwise max layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n \nclass SumLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n \n dic['stride'] = mcp.safe_get_int(name, 'stride', default=1)\n self.verify_divisible(dic['numInputs'][0], dic['stride'], 'input dimensionality', 'stride')\n dic['outputs'] = dic['numInputs'][0] / dic['stride']\n \n print \"Initialized sum layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n \nclass DropoutLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def add_params(self, mcp):\n LayerWithInputParser.add_params(self, mcp)\n dic, name = self.dic, self.dic['name']\n dic['enable'] = mcp.safe_get_bool(name, 'enable', default=True)\n dic['keep'] = mcp.safe_get_float(name, 'keep', default=0.5)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['requiresParams'] = True\n dic['usesInputs'] = False\n dic['usesActs'] = False\n dic['forceOwnActs'] = False\n dic['outputs'] = dic['numInputs'][0]\n\n print \"Initialized %s layer '%s' on GPUs %s, producing %d outputs\" % (dic['type'], name, dic['gpus'], dic['outputs'])\n return dic\n \nclass Dropout2LayerParser(DropoutLayerParser):\n def __init__(self):\n DropoutLayerParser.__init__(self)\n \nclass WeightLayerParser(LayerWithInputParser):\n LAYER_PAT = re.compile(r'^\\s*([^\\s\\[]+)(?:\\[(\\d+)\\])?\\s*$') # matches things like layername[5], etc\n \n def __init__(self, num_inputs=-1):\n LayerWithInputParser.__init__(self, num_inputs=num_inputs)\n \n @staticmethod\n def get_layer_name(name_str):\n m = WeightLayerParser.LAYER_PAT.match(name_str)\n if not m:\n return None\n return m.group(1), m.group(2)\n \n def add_params(self, mcp):\n LayerWithInputParser.add_params(self, mcp)\n dic, name = self.dic, self.dic['name']\n dic['momW'] = mcp.safe_get_float_list(name, 'momW')\n dic['momB'] = mcp.safe_get_float(name, 'momB')\n dic['superEps'] = mcp.safe_get_float(name, 'superEps', default=0.0)\n dic['superMom'] = mcp.safe_get_float(name, 'superMom', default=0.0)\n dic['wc'] = mcp.safe_get_float_list(name, 'wc', default=[0.0] * len(dic['inputs']))\n dic['wball'] = mcp.safe_get_float_list(name, 'wball', default=[0.0] * len(dic['inputs']))\n self.verify_num_params(['momW', 'wc', 'wball'])\n# dic['wballNormed'] = [wball * nweights for wball,nweights in zip(dic['wball'], dic['weightsPerFilter'])]\n dic['wballNormed'] = dic['wball']\n \n # Convert from old-style 0.001,0.02 hyperparam specification to new-stye\n # const[base=0.001],const[base=0.02] and so forth\n def convert_scalars_to_schedules(scalars):\n parts = scalars.split(',')\n for i,p in enumerate(parts):\n p = p.strip()\n if re.match('(?:\\d*\\.)?\\d+$', p):\n parts[i] = 'const[base=%s]' % p\n return parts\n \n dic['epsW'] = self.parse_params(convert_scalars_to_schedules(mcp.safe_get(name, 'epsW')), lrs_parsers, 'epsW', 'learning rate schedule', num_params=len(dic['inputs']))\n dic['epsB'] = self.parse_params(convert_scalars_to_schedules(mcp.safe_get(name, 'epsB')), lrs_parsers, 'epsB', 'learning rate schedule', num_params=1)[0]\n \n dic['updatePeriod'] = mcp.safe_get_int(name, 'updatePeriod', default=0) # 0 means update as often as possible\n # TODO: assert that updatePeriod is a multiple of active pass period, which is unknown here.\n # the assert has to go in some post-processing step..\n dic['gradConsumer'] = dic['epsB']['params']['base'] > 0 or any(w['params']['base'] > 0 for w in dic['epsW'])\n\n @staticmethod\n def unshare_weights(layer, layers, matrix_idx=None):\n def unshare(layer, layers, indices):\n for i in indices:\n if layer['weightSourceLayers'][i] >= 0:\n src_matrix_idx = layer['weightSourceMatrixIndices'][i]\n layer['weightSourceLayers'][i] = \"\"\n layer['weightSourceMatrixIndices'][i] = -1\n layer['weights'][i] = layer['weights'][i].copy()\n layer['weightsInc'][i] = n.zeros_like(layer['weights'][i])\n print \"Unshared weight matrix %s[%d] from %s[%d].\" % (layer['name'], i, layer['weightSourceLayers'][i], src_matrix_idx)\n else:\n print \"Weight matrix %s[%d] already unshared.\" % (layer['name'], i)\n if 'weightSourceLayers' in layer:\n unshare(layer, layers, range(len(layer['inputs'])) if matrix_idx is None else [matrix_idx])\n\n # Load weight/biases initialization module\n def call_init_func(self, param_name, shapes, input_idx=-1):\n dic = self.dic\n func_pat = re.compile('^([^\\.]+)\\.([^\\(\\)]+)\\s*(?:\\(([^,]+(?:,[^,]+)*)\\))?$')\n m = func_pat.match(dic[param_name])\n if not m:\n raise LayerParsingError(\"Layer '%s': '%s' parameter must have format 'moduleName.functionName(param1,param2,...)'; got: %s.\" % (dic['name'], param_name, dic['initWFunc']))\n module, func = m.group(1), m.group(2)\n params = m.group(3).split(',') if m.group(3) is not None else []\n try:\n mod = __import__(module)\n return getattr(mod, func)(dic['name'], input_idx, shapes, params=params) if input_idx >= 0 else getattr(mod, func)(dic['name'], shapes, params=params)\n except (ImportError, AttributeError, TypeError), e:\n raise LayerParsingError(\"Layer '%s': %s.\" % (dic['name'], e))\n \n def make_weights(self, initW, rows, cols, order='C'):\n dic = self.dic\n dic['weights'], dic['weightsInc'] = [], []\n if dic['initWFunc']: # Initialize weights from user-supplied python function\n # Initialization function is supplied in the format\n # module.func\n for i in xrange(len(dic['inputs'])):\n dic['weights'] += [self.call_init_func('initWFunc', (rows[i], cols[i]), input_idx=i)]\n\n if type(dic['weights'][i]) != n.ndarray:\n raise LayerParsingError(\"Layer '%s[%d]': weight initialization function %s must return numpy.ndarray object. Got: %s.\" % (dic['name'], i, dic['initWFunc'], type(dic['weights'][i])))\n if dic['weights'][i].dtype != n.float32:\n raise LayerParsingError(\"Layer '%s[%d]': weight initialization function %s must weight matrices consisting of single-precision floats. Got: %s.\" % (dic['name'], i, dic['initWFunc'], dic['weights'][i].dtype))\n if dic['weights'][i].shape != (rows[i], cols[i]):\n raise LayerParsingError(\"Layer '%s[%d]': weight matrix returned by weight initialization function %s has wrong shape. Should be: %s; got: %s.\" % (dic['name'], i, dic['initWFunc'], (rows[i], cols[i]), dic['weights'][i].shape))\n # Convert to desired order\n dic['weights'][i] = n.require(dic['weights'][i], requirements=order)\n dic['weightsInc'] += [n.zeros_like(dic['weights'][i])]\n print \"Layer '%s[%d]' initialized weight matrices from function %s\" % (dic['name'], i, dic['initWFunc'])\n else:\n for i in xrange(len(dic['inputs'])):\n if dic['weightSourceLayers'][i] != '': # Shared weight matrix\n src_layer = self.prev_layers[dic['weightSourceLayers'][i]] if dic['weightSourceLayers'][i] != dic['name'] else dic\n dic['weights'] += [src_layer['weights'][dic['weightSourceMatrixIndices'][i]]]\n dic['weightsInc'] += [src_layer['weightsInc'][dic['weightSourceMatrixIndices'][i]]]\n if dic['weights'][i].shape != (rows[i], cols[i]):\n raise LayerParsingError(\"Layer '%s': weight sharing source matrix '%s' has shape %dx%d; should be %dx%d.\" \n % (dic['name'], dic['weightSource'][i], dic['weights'][i].shape[0], dic['weights'][i].shape[1], rows[i], cols[i]))\n print \"Layer '%s' initialized weight matrix %d from %s\" % (dic['name'], i, dic['weightSource'][i])\n else:\n dic['weights'] += [n.array(initW[i] * nr.randn(rows[i], cols[i]), dtype=n.single, order=order)]\n dic['weightsInc'] += [n.zeros_like(dic['weights'][i])]\n \n def make_biases(self, rows, cols, order='C'):\n dic = self.dic\n if dic['initBFunc']:\n dic['biases'] = self.call_init_func('initBFunc', (rows, cols))\n if type(dic['biases']) != n.ndarray:\n raise LayerParsingError(\"Layer '%s': bias initialization function %s must return numpy.ndarray object. Got: %s.\" % (dic['name'], dic['initBFunc'], type(dic['biases'])))\n if dic['biases'].dtype != n.float32:\n raise LayerParsingError(\"Layer '%s': bias initialization function %s must return numpy.ndarray object consisting of single-precision floats. Got: %s.\" % (dic['name'], dic['initBFunc'], dic['biases'].dtype))\n if dic['biases'].shape != (rows, cols):\n raise LayerParsingError(\"Layer '%s': bias vector returned by bias initialization function %s has wrong shape. Should be: %s; got: %s.\" % (dic['name'], dic['initBFunc'], (rows, cols), dic['biases'].shape))\n\n dic['biases'] = n.require(dic['biases'], requirements=order)\n print \"Layer '%s' initialized bias vector from function %s\" % (dic['name'], dic['initBFunc'])\n else:\n dic['biases'] = dic['initB'] * n.ones((rows, cols), order=order, dtype=n.single)\n dic['biasesInc'] = n.zeros_like(dic['biases'])\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['requiresParams'] = True\n dic['gradConsumer'] = True\n dic['usesActs'] = False\n dic['initW'] = mcp.safe_get_float_list(name, 'initW', default=0.01)\n dic['initB'] = mcp.safe_get_float(name, 'initB', default=0)\n dic['initWFunc'] = mcp.safe_get(name, 'initWFunc', default=\"\")\n dic['initBFunc'] = mcp.safe_get(name, 'initBFunc', default=\"\")\n # Find shared weight matrices\n \n dic['weightSource'] = mcp.safe_get_list(name, 'weightSource', default=[''] * len(dic['inputs']))\n self.verify_num_params(['initW'])\n self.verify_num_params(['weightSource'], auto_expand=False)\n \n dic['weightSourceLayers'] = []\n dic['weightSourceMatrixIndices'] = []\n\n for i, src_name in enumerate(dic['weightSource']):\n src_layer_matrix_idx = -1\n src_layer_name = ''\n if src_name != '':\n src_layer_match = WeightLayerParser.get_layer_name(src_name)\n if src_layer_match is None:\n raise LayerParsingError(\"Layer '%s': unable to parse weight sharing source '%s'. Format is layer[idx] or just layer, in which case idx=0 is used.\" % (name, src_name))\n src_layer_name = src_layer_match[0]\n src_layer_matrix_idx = int(src_layer_match[1]) if src_layer_match[1] is not None else 0\n\n if src_layer_name not in prev_layers and src_layer_name != name:\n raise LayerParsingError(\"Layer '%s': weight sharing source layer '%s' does not exist.\" % (name, src_layer_name))\n \n# src_layer_idx = prev_names.index(src_layer_name) if src_layer_name != name else len(prev_names)\n src_layer = prev_layers[src_layer_name] if src_layer_name != name else dic\n if src_layer['gpu'] != dic['gpu']:\n raise LayerParsingError(\"Layer '%s': weight sharing source layer '%s' runs on GPUs %s, while '%s' runs on GPUs %s.\" % (name, src_layer_name, src_layer['gpu'], name, dic['gpu']))\n if src_layer['type'] != dic['type']:\n raise LayerParsingError(\"Layer '%s': weight sharing source layer '%s' is of type '%s'; should be '%s'.\" % (name, src_layer_name, src_layer['type'], dic['type']))\n if src_layer_name != name and len(src_layer['weights']) <= src_layer_matrix_idx:\n raise LayerParsingError(\"Layer '%s': weight sharing source layer '%s' has %d weight matrices, but '%s[%d]' requested.\" % (name, src_layer_name, len(src_layer['weights']), src_name, src_layer_matrix_idx))\n if src_layer_name == name and src_layer_matrix_idx >= i:\n raise LayerParsingError(\"Layer '%s': weight sharing source '%s[%d]' not defined yet.\" % (name, name, src_layer_matrix_idx))\n\n dic['weightSourceLayers'] += [src_layer_name]\n dic['weightSourceMatrixIndices'] += [src_layer_matrix_idx]\n \n return dic\n \nclass FCLayerParser(WeightLayerParser):\n def __init__(self):\n WeightLayerParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = WeightLayerParser.parse(self, name, mcp, prev_layers, model)\n \n dic['outputs'] = mcp.safe_get_int(name, 'outputs')\n dic['weightsPerFilter'] = dic['numInputs']\n self.verify_num_range(dic['outputs'], 'outputs', 1, None)\n self.make_weights(dic['initW'], dic['numInputs'], [dic['outputs']] * len(dic['numInputs']), order='F')\n self.make_biases(1, dic['outputs'], order='F')\n\n print \"Initialized fully-connected layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n \nclass SplitFCLayerParser(WeightLayerParser):\n def __init__(self):\n WeightLayerParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = WeightLayerParser.parse(self, name, mcp, prev_layers, model)\n dic['parts'] = mcp.safe_get_int(name, 'parts')\n dic['outputs'] = mcp.safe_get_int(name, 'outputs') * dic['parts']\n dic['weightsPerFilter'] = dic['numInputs']\n self.verify_num_range(dic['parts'], 'parts', 1, None)\n \n self.make_weights(dic['initW'], dic['numInputs'], [dic['outputs']/dic['parts']] * len(dic['numInputs']), order='F')\n self.make_biases(1, dic['outputs'], order='F')\n \n for i in xrange(len(dic['numInputs'])):\n self.verify_divisible(dic['numInputs'][i], dic['parts'], 'numInputs', 'parts', input_idx=i)\n \n print \"Initialized split fully-connected layer '%s' on GPUs %s, producing %d outputs in %d parts\" % (name, dic['gpus'], dic['outputs'], dic['parts'])\n return dic\n \nclass LocalLayerParser(WeightLayerParser):\n def __init__(self):\n WeightLayerParser.__init__(self)\n \n # Convert convolutional layer to unshared, locally-connected layer\n @staticmethod\n def conv_to_local(layers, lname):\n layer = layers[lname]\n if layer['type'] == 'conv':\n layer['type'] = 'local'\n for inp,inpname in enumerate(layer['inputs']):\n src_layer_name = layer['weightSourceLayers'][inp]\n if src_layer_name != '':\n src_layer = layers[src_layer_name]\n src_matrix_idx = layer['weightSourceMatrixIndices'][inp]\n LocalLayerParser.conv_to_local(layers, src_layer_name)\n for w in ('weights', 'weightsInc'):\n layer[w][inp] = src_layer[w][src_matrix_idx]\n else:\n layer['weights'][inp] = n.require(n.reshape(n.tile(n.reshape(layer['weights'][inp], (1, n.prod(layer['weights'][inp].shape))), (layer['modules'], 1)),\n (layer['modules'] * layer['filterChannels'][inp] * layer['filterPixels'][inp], layer['filters'])),\n requirements='C')\n layer['weightsInc'][inp] = n.zeros_like(layer['weights'][inp])\n if layer['sharedBiases']:\n layer['biases'] = n.require(n.repeat(layer['biases'], layer['modules'], axis=0), requirements='C')\n layer['biasesInc'] = n.zeros_like(layer['biases'])\n \n print \"Converted layer '%s' from convolutional to unshared, locally-connected\" % layer['name']\n \n # Also call this function on any layers sharing my weights\n for l in layers:\n if 'weightSourceLayers' in l and lname in l['weightSourceLayers']:\n LocalLayerParser.conv_to_local(layers, l)\n return layer\n \n def parse(self, name, mcp, prev_layers, model):\n dic = WeightLayerParser.parse(self, name, mcp, prev_layers, model)\n dic['requiresParams'] = True\n dic['usesActs'] = False\n # Supplied values\n dic['channels'] = mcp.safe_get_int_list(name, 'channels')\n dic['padding'] = mcp.safe_get_int_list(name, 'padding', default=[0]*len(dic['inputs']))\n dic['stride'] = mcp.safe_get_int_list(name, 'stride', default=[1]*len(dic['inputs']))\n dic['filterSize'] = mcp.safe_get_int_list(name, 'filterSize')\n dic['filters'] = mcp.safe_get_int_list(name, 'filters')\n dic['groups'] = mcp.safe_get_int_list(name, 'groups', default=[1]*len(dic['inputs']))\n dic['initW'] = mcp.safe_get_float_list(name, 'initW')\n dic['initCFunc'] = mcp.safe_get(name, 'initCFunc', default='')\n dic['modulesX'] = mcp.safe_get_int(name, 'modulesX', default=0)\n\n \n self.verify_num_params(['channels', 'padding', 'stride', 'filterSize', \\\n 'filters', 'groups', 'initW'])\n \n self.verify_num_range(dic['stride'], 'stride', 1, None)\n self.verify_num_range(dic['filterSize'],'filterSize', 1, None) \n self.verify_num_range(dic['padding'], 'padding', 0, None)\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n self.verify_num_range(dic['groups'], 'groups', 1, None)\n self.verify_num_range(dic['modulesX'], 'modulesX', 0, None)\n for i in xrange(len(dic['filters'])):\n self.verify_divisible(dic['filters'][i], 16, 'filters', input_idx=i)\n \n # Computed values\n dic['imgPixels'] = [numInputs/channels for numInputs,channels in zip(dic['numInputs'], dic['channels'])]\n dic['imgSize'] = [int(n.sqrt(imgPixels)) for imgPixels in dic['imgPixels']]\n self.verify_num_range(dic['imgSize'], 'imgSize', 1, None)\n dic['filters'] = [filters*groups for filters,groups in zip(dic['filters'], dic['groups'])]\n dic['filterPixels'] = [filterSize**2 for filterSize in dic['filterSize']]\n if dic['modulesX'] <= 0:\n dic['modulesX'] = [1 + int(ceil((2*padding + imgSize - filterSize) / float(stride))) for padding,imgSize,filterSize,stride in zip(dic['padding'], dic['imgSize'], dic['filterSize'], dic['stride'])]\n else:\n dic['modulesX'] = [dic['modulesX']] * len(dic['inputs'])\n\n dic['filterChannels'] = [channels/groups for channels,groups in zip(dic['channels'], dic['groups'])]\n \n if len(set(dic['modulesX'])) != 1 or len(set(dic['filters'])) != 1:\n raise LayerParsingError(\"Layer '%s': all inputs must produce equally-dimensioned output. Dimensions are: %s.\" % (name, \", \".join(\"%dx%dx%d\" % (filters, modulesX, modulesX) for filters,modulesX in zip(dic['filters'], dic['modulesX']))))\n\n dic['modulesX'] = dic['modulesX'][0]\n dic['modules'] = dic['modulesX']**2\n dic['filters'] = dic['filters'][0]\n dic['outputs'] = dic['modules'] * dic['filters']\n# dic['filterConns'] = [[]] * len(dic['inputs'])\n for i in xrange(len(dic['inputs'])):\n if dic['numInputs'][i] % dic['imgPixels'][i] != 0 or dic['imgSize'][i] * dic['imgSize'][i] != dic['imgPixels'][i]:\n raise LayerParsingError(\"Layer '%s[%d]': has %-d dimensional input, not interpretable as square %d-channel images\" % (name, i, dic['numInputs'][i], dic['channels'][i]))\n if dic['channels'][i] > 3 and dic['channels'][i] % 4 != 0:\n raise LayerParsingError(\"Layer '%s[%d]': number of channels must be smaller than 4 or divisible by 4\" % (name, i))\n# if dic['filterSize'][i] > totalPadding[i] + dic['imgSize'][i]:\n# raise LayerParsingError(\"Layer '%s[%d]': filter size (%d) greater than image size + padding (%d)\" % (name, i, dic['filterSize'][i], dic['padding'][i] + dic['imgSize'][i]))\n if -dic['padding'][i] + dic['stride'][i] * (dic['modulesX'] - 1) + dic['filterSize'][i] < dic['imgSize'][i]:\n raise LayerParsingError(\"Layer '%s[%d]': %dx%d output map with padding=%d, stride=%d does not cover entire input image.\" % (name, i, dic['modulesX'], dic['outputsX'], dic['padding'][i], dic['stride'][i]))\n\n if dic['groups'][i] > 1:\n self.verify_divisible(dic['channels'][i], 4*dic['groups'][i], 'channels', '4 * groups', input_idx=i)\n self.verify_divisible(dic['channels'][i], dic['groups'][i], 'channels', 'groups', input_idx=i)\n\n self.verify_divisible(dic['filters'], 16*dic['groups'][i], 'filters * groups', input_idx=i)\n \n \n dic['padding'][i] = -dic['padding'][i]\n# dic['overSample'] = [groups*filterChannels/channels for groups,filterChannels,channels in zip(dic['groups'], dic['filterChannels'], dic['channels'])]\n dic['weightsPerFilter'] = [fc * (fz**2) for fc, fz in zip(dic['filterChannels'], dic['filterSize'])]\n \n return dic \n\nclass ConvLayerParser(LocalLayerParser):\n def __init__(self):\n LocalLayerParser.__init__(self)\n \n def add_params(self, mcp):\n LocalLayerParser.add_params(self, mcp)\n self.dic['wcNormMax'] = mcp.safe_get_float_list(self.dic['name'], 'wcNormMax', default=[0.0] * len(self.dic['inputs']))\n self.dic['wcNormMin'] = mcp.safe_get_float_list(self.dic['name'], 'wcNormMin', default=[0.0] * len(self.dic['inputs']))\n self.verify_num_params(['wcNormMax', 'wcNormMin'])\n for min,max in zip(self.dic['wcNormMin'], self.dic['wcNormMax']):\n if min > max:\n raise LayerParsingError(\"Layer '%s': wcNormMin must be <= wcNormMax.\" % (self.dic['name']))\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LocalLayerParser.parse(self, name, mcp, prev_layers, model)\n \n dic['sumWidth'] = mcp.safe_get_int(name, 'sumWidth')\n dic['sharedBiases'] = mcp.safe_get_bool(name, 'sharedBiases', default=True)\n \n num_biases = dic['filters'] if dic['sharedBiases'] else dic['modules']*dic['filters']\n\n eltmult = lambda list1, list2: [l1 * l2 for l1,l2 in zip(list1, list2)]\n self.make_weights(dic['initW'], eltmult(dic['filterPixels'], dic['filterChannels']), [dic['filters']] * len(dic['inputs']), order='C')\n self.make_biases(num_biases, 1, order='C')\n\n print \"Initialized convolutional layer '%s' on GPUs %s, producing %dx%d %d-channel output\" % (name, dic['gpus'], dic['modulesX'], dic['modulesX'], dic['filters'])\n return dic \n \nclass LocalUnsharedLayerParser(LocalLayerParser):\n def __init__(self):\n LocalLayerParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LocalLayerParser.parse(self, name, mcp, prev_layers, model)\n eltmult = lambda list1, list2: [l1 * l2 for l1,l2 in zip(list1, list2)]\n scmult = lambda x, lst: [x * l for l in lst]\n self.make_weights(dic['initW'], scmult(dic['modules'], eltmult(dic['filterPixels'], dic['filterChannels'])), [dic['filters']] * len(dic['inputs']), order='C')\n self.make_biases(dic['modules'] * dic['filters'], 1, order='C')\n \n print \"Initialized locally-connected layer '%s' on GPUs %s, producing %dx%d %d-channel output\" % (name, dic['gpus'], dic['modulesX'], dic['modulesX'], dic['filters'])\n return dic \n \nclass DataLayerParser(LayerParser):\n def __init__(self):\n LayerParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerParser.parse(self, name, mcp, prev_layers, model)\n dic['dataIdx'] = mcp.safe_get_int(name, 'dataIdx')\n dic['start'] = mcp.safe_get_int(name, 'start', default=0)\n dic['end'] = mcp.safe_get_int(name, 'end', default=model.train_data_provider.get_data_dims(idx=dic['dataIdx']))\n dic['outputs'] = dic['end'] - dic['start']\n# dic['usesActs'] = False\n print \"Initialized data layer '%s', producing %d outputs\" % (name, dic['outputs'])\n return dic\n\nclass SoftmaxLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['outputs'] = dic['inputLayers'][0]['outputs']\n print \"Initialized softmax layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n \nclass ConcatentionLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['outputs'] = sum(l['outputs'] for l in dic['inputLayers'])\n dic['copyOffsets'] = [sum(dic['inputLayers'][j]['outputs'] for j in xrange(i)) for i in xrange(len(dic['inputLayers']))]\n print \"Initialized concatenation layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n \nclass PassThroughLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self)\n \n # Note: this doesn't verify all the necessary constraints. Layer construction may still fail in C++ code.\n # For example, it does not verify that every layer only has one pass-through parent. Obviously having \n # two such parents is incoherent.\n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n# if len(dic['inputLayers']) == 1:\n# raise LayerParsingError(\"Layer %s: pass-through layer must have more than one input.\" % dic['name'])\n if len(dic['gpu']) != len(dic['inputLayers'][0]['gpu']):\n raise LayerParsingError(\"Layer '%s': number of replicas in pass-through layer must be equivalent to number of replicas in input layers.\" % dic['name'])\n for inp in dic['inputLayers']:\n conflicting_layers = [l for l in prev_layers.values() if l['type'] == 'pass' and inp['name'] in l['inputs'] and len(set(dic['gpu']).intersection(set(l['gpu']))) > 0]\n if len(conflicting_layers) > 0:\n raise LayerParsingError(\"Layer '%s' conflicts with layer '%s'. Both pass-through layers take layer '%s' as input and operate on an overlapping set of GPUs.\" % (dic['name'], conflicting_layers[0]['name'], inp['name']))\n dic['outputs'] = sum(l['outputs'] for l in dic['inputLayers'])\n# dic['copyOffsets'] = [sum(dic['inputLayers'][j]['outputs'] for j in xrange(i)) for i in xrange(len(dic['inputLayers']))]\n print \"Initialized pass-through layer '%s' on GPUs %s, producing %d outputs\" % (name, dic['gpus'], dic['outputs'])\n return dic\n\nclass PoolLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def add_params(self, mcp):\n LayerWithInputParser.add_params(self, mcp)\n dic, name = self.dic, self.dic['name']\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['channels'] = mcp.safe_get_int(name, 'channels')\n dic['sizeX'] = mcp.safe_get_int(name, 'sizeX')\n dic['start'] = mcp.safe_get_int(name, 'start', default=0)\n dic['stride'] = mcp.safe_get_int(name, 'stride')\n dic['outputsX'] = mcp.safe_get_int(name, 'outputsX', default=0)\n dic['pool'] = mcp.safe_get(name, 'pool')\n \n # Avg pooler does not use its acts or inputs\n dic['usesActs'] = dic['pool'] != 'avg'\n dic['usesInputs'] = dic['pool'] != 'avg'\n \n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n \n if dic['pool'] == 'avg':\n dic['sum'] = mcp.safe_get_bool(name, 'sum', default=False)\n \n self.verify_num_range(dic['sizeX'], 'sizeX', 1, dic['imgSize'])\n self.verify_num_range(dic['stride'], 'stride', 1, dic['sizeX'])\n self.verify_num_range(dic['outputsX'], 'outputsX', 0, None)\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n \n if LayerWithInputParser.grad_consumers_below(dic):\n self.verify_divisible(dic['channels'], 16, 'channels')\n self.verify_str_in(dic['pool'], 'pool', ['max', 'maxabs', 'avg'])\n \n self.verify_img_size()\n\n if dic['outputsX'] <= 0:\n dic['outputsX'] = int(ceil((dic['imgSize'] - dic['start'] - dic['sizeX']) / float(dic['stride']))) + 1;\n dic['outputs'] = dic['outputsX']**2 * dic['channels']\n \n print \"Initialized %s-pooling layer '%s' on GPUs %s, producing %dx%d %d-channel output\" % (dic['pool'], name, dic['gpus'], dic['outputsX'], dic['outputsX'], dic['channels'])\n return dic\n \n\nclass CrossMapPoolLayerParser(LayerWithInputParser):\n def __init__(self):\n LayerWithInputParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['channels'] = mcp.safe_get_int(name, 'channels')\n dic['size'] = mcp.safe_get_int(name, 'size')\n dic['start'] = mcp.safe_get_int(name, 'start', default=0)\n dic['stride'] = mcp.safe_get_int(name, 'stride')\n dic['outputChannels'] = mcp.safe_get_int(name, 'outputs', default=0)\n dic['pool'] = mcp.safe_get(name, 'pool')\n dic['requiresParams'] = False\n \n # Avg pooler does not use its acts or inputs\n dic['usesActs'] = 'pool' != 'avg'\n dic['usesInputs'] = 'pool' != 'avg'\n \n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n dic['outputs'] = dic['outputChannels'] * dic['imgPixels']\n \n self.verify_num_range(dic['size'], 'size', 1, dic['channels'])\n self.verify_num_range(dic['stride'], 'stride', 1, dic['size'])\n self.verify_num_range(dic['outputChannels'], 'outputChannels', 0, None)\n self.verify_num_range(dic['channels'], 'channels', 1, None)\n self.verify_num_range(dic['start'], 'start', None, 0)\n \n self.verify_str_in(dic['pool'], 'pool', ['max'])\n self.verify_img_size()\n \n covered_chans = dic['start'] + (dic['outputChannels'] - 1) * dic['stride'] + dic['size']\n if covered_chans < dic['channels']:\n raise LayerParsingError(\"Layer '%s': cross-map pooling with start=%d, stride=%d, size=%d, outputs=%d covers only %d of %d input channels.\" % \\\n (name, dic['start'], dic['stride'], dic['size'], dic['outputChannels'], covered_chans, dic['channels']))\n \n print \"Initialized cross-map %s-pooling layer '%s' on GPUs %s, producing %dx%d %d-channel output\" % (dic['pool'], name, dic['gpus'], dic['imgSize'], dic['imgSize'], dic['outputChannels'])\n return dic\n \nclass NormLayerParser(LayerWithInputParser):\n RESPONSE_NORM = 'response'\n CONTRAST_NORM = 'contrast'\n CROSSMAP_RESPONSE_NORM = 'cross-map response'\n \n def __init__(self, norm_type):\n LayerWithInputParser.__init__(self, num_inputs=1)\n self.norm_type = norm_type\n \n def add_params(self, mcp):\n LayerWithInputParser.add_params(self, mcp)\n dic, name = self.dic, self.dic['name']\n dic['scale'] = mcp.safe_get_float(name, 'scale')\n dic['scale'] /= dic['size'] if self.norm_type == self.CROSSMAP_RESPONSE_NORM else dic['size']**2\n dic['pow'] = mcp.safe_get_float(name, 'pow')\n dic['minDiv'] = mcp.safe_get_float(name, 'minDiv', default=1.0)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['requiresParams'] = True\n dic['channels'] = mcp.safe_get_int(name, 'channels')\n dic['size'] = mcp.safe_get_int(name, 'size')\n dic['blocked'] = mcp.safe_get_bool(name, 'blocked', default=False)\n \n dic['imgPixels'] = dic['numInputs'][0] / dic['channels']\n dic['imgSize'] = int(n.sqrt(dic['imgPixels']))\n \n # Contrast normalization layer does not use its inputs\n dic['usesInputs'] = self.norm_type != self.CONTRAST_NORM\n \n self.verify_num_range(dic['channels'], 'channels', 1, None)\n if self.norm_type == self.CROSSMAP_RESPONSE_NORM: \n self.verify_num_range(dic['size'], 'size', 2, dic['channels'])\n if dic['channels'] % 16 != 0:\n raise LayerParsingError(\"Layer '%s': number of channels must be divisible by 16 when using crossMap\" % name)\n else:\n self.verify_num_range(dic['size'], 'size', 1, dic['imgSize'])\n \n if self.norm_type != self.CROSSMAP_RESPONSE_NORM and dic['channels'] > 3 and dic['channels'] % 4 != 0:\n raise LayerParsingError(\"Layer '%s': number of channels must be smaller than 4 or divisible by 4\" % name)\n\n self.verify_img_size()\n\n dic['outputs'] = dic['imgPixels'] * dic['channels']\n print \"Initialized %s-normalization layer '%s' on GPUs %s, producing %dx%d %d-channel output\" % (self.norm_type, name, dic['gpus'], dic['imgSize'], dic['imgSize'], dic['channels'])\n return dic\n\nclass CostParser(LayerWithInputParser):\n def __init__(self, num_inputs=-1):\n LayerWithInputParser.__init__(self, num_inputs=num_inputs)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = LayerWithInputParser.parse(self, name, mcp, prev_layers, model)\n dic['requiresParams'] = True\n # Stored as string because python can't pickle lambda functions\n dic['outputFilter'] = 'lambda costs,num_cases: [c/num_cases for c in costs]'\n dic['children'] = mcp.safe_get_list(name, 'children', default=[])\n # Aggregated costs only produce outputs which are additive.\n for c in dic['children']:\n if c not in prev_layers:\n raise LayerParsingError(\"Layer '%s': child cost layer '%s' not defined\" % (name, c))\n if prev_layers[c]['type'] != dic['type']:\n raise LayerParsingError(\"Layer '%s': child cost layer '%s' must have same type as parent\" % (name, c))\n prev_layers[c]['aggregated'] = 1\n dic['aggregated'] = dic['children'] != []\n del dic['neuron']\n return dic\n\n def add_params(self, mcp):\n LayerWithInputParser.add_params(self, mcp)\n dic, name = self.dic, self.dic['name']\n dic['coeff'] = mcp.safe_get_float(name, 'coeff')\n dic['gradConsumer'] = dic['coeff'] > 0\n \nclass CrossEntCostParser(CostParser):\n def __init__(self):\n CostParser.__init__(self, num_inputs=2)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = CostParser.parse(self, name, mcp, prev_layers, model)\n if dic['numInputs'][0] != model.train_data_provider.get_num_classes(): # first input must be labels\n raise LayerParsingError(\"Layer '%s': Dimensionality of first input must be equal to number of labels\" % name)\n if dic['inputLayers'][1]['type'] != 'softmax':\n raise LayerParsingError(\"Layer '%s': Second input must be softmax layer\" % name)\n if dic['numInputs'][1] != model.train_data_provider.get_num_classes():\n raise LayerParsingError(\"Layer '%s': Softmax input '%s' must produce %d outputs, because that is the number of classes in the dataset\" \\\n % (name, dic['inputs'][1], model.train_data_provider.get_num_classes()))\n \n print \"Initialized cross-entropy cost '%s' on GPUs %s\" % (name, dic['gpus'])\n return dic\n \nclass LogregCostParser(CostParser):\n def __init__(self):\n CostParser.__init__(self, num_inputs=2)\n \n def add_params(self, mcp):\n CostParser.add_params(self, mcp)\n dic, name = self.dic, self.dic['name']\n dic['topk'] = mcp.safe_get_int(name, 'topk', default=1)\n if dic['topk'] > dic['numInputs'][1]:\n raise LayerParsingError(\"Layer '%s': parameter 'topk'must not have value greater than the number of classess.\" % (name))\n \n def parse(self, name, mcp, prev_layers, model):\n dic = CostParser.parse(self, name, mcp, prev_layers, model)\n dic['requiresParams'] = True\n if dic['numInputs'][0] != 1: # first input must be labels\n raise LayerParsingError(\"Layer '%s': dimensionality of first input must be 1\" % name)\n if dic['inputLayers'][1]['type'] != 'softmax':\n raise LayerParsingError(\"Layer '%s': second input must be softmax layer\" % name)\n if dic['numInputs'][1] != model.train_data_provider.get_num_classes():\n raise LayerParsingError(\"Layer '%s': softmax input '%s' must produce %d outputs, because that is the number of classes in the dataset\" \\\n % (name, dic['inputs'][1], model.train_data_provider.get_num_classes()))\n \n print \"Initialized logistic regression cost '%s' on GPUs %s\" % (name, dic['gpus'])\n return dic\n \nclass BinomialCrossEntCostParser(CostParser):\n def __init__(self):\n CostParser.__init__(self, num_inputs=2)\n \n def add_params(self, mcp):\n CostParser.add_params(self, mcp)\n self.dic['posWeight'] = mcp.safe_get_float(self.dic['name'], 'posWeight', default=1.0)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = CostParser.parse(self, name, mcp, prev_layers, model)\n\n if dic['numInputs'][0] != dic['numInputs'][1]:\n raise LayerParsingError(\"Layer '%s': both inputs must produce the same number of outputs\" % (name))\n\n if 'neuron' not in dic['inputLayers'][1] or dic['inputLayers'][1]['neuron'] != 'logistic':\n print \"WARNING: Layer '%s': input '%s' is not logistic, results may not be what you intend.\" % (dic['name'], dic['inputs'][1])\n \n if dic['type'] == 'cost.bce':\n print \"Initialized binomial cross-entropy cost '%s' on GPUs %s\" % (name, dic['gpus'])\n \n \n dic['computeSoftmaxErrorRate'] = True\n return dic\n \nclass DetectionCrossEntCostParser(BinomialCrossEntCostParser):\n def __init__(self):\n BinomialCrossEntCostParser.__init__(self)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = BinomialCrossEntCostParser.parse(self, name, mcp, prev_layers, model)\n if dic['numInputs'][0] != model.train_data_provider.get_num_classes(): # first input must be labels\n raise LayerParsingError(\"Layer '%s': Dimensionality of first input must be equal to number of labels\" % name)\n dic['computeSoftmaxErrorRate'] = False\n dic['outputFilter'] = 'lambda costs,num_cases: [c/num_cases for c in costs[:2]] + [(class_cost[2] / class_cost[j] if class_cost[j] > 0 else n.inf) for class_cost in [costs[2:][i*3:(i+1)*3] for i in range(len(costs[2:])/3)] for j in range(2)]'\n dic['outputFilterFormatter'] = 'lambda self,costs: \"(crossent) %.6f, (err) %.6f, \" % (costs[0], costs[1]) + \", \".join(\"(%s) %.6f, %.6f\" % (self.train_data_provider.batch_meta[\"label_names\"][i/2-1],costs[i],costs[i+1]) for i in xrange(2, len(costs), 2))'\n print \"Initialized detection cross-entropy cost '%s' on GPUs %s\" % (name, dic['gpus'])\n return dic\n \nclass SumOfSquaresCostParser(CostParser):\n def __init__(self):\n CostParser.__init__(self, num_inputs=1)\n \n def parse(self, name, mcp, prev_layers, model):\n dic = CostParser.parse(self, name, mcp, prev_layers, model)\n print \"Initialized sum-of-squares cost '%s' on GPUs %s\" % (name, dic['gpus'])\n return dic\n \n# All the layer parsers\nlayer_parsers = {'data' : lambda : DataLayerParser(),\n 'fc': lambda : FCLayerParser(),\n 'sfc': lambda : SplitFCLayerParser(),\n 'conv': lambda : ConvLayerParser(),\n 'local': lambda : LocalUnsharedLayerParser(),\n 'softmax': lambda : SoftmaxLayerParser(),\n 'eltsum': lambda : EltwiseSumLayerParser(),\n 'eltmax': lambda : EltwiseMaxLayerParser(),\n 'sum': lambda : SumLayerParser(),\n 'neuron': lambda : NeuronLayerParser(),\n 'pool': lambda : PoolLayerParser(),\n 'cmpool': lambda : CrossMapPoolLayerParser(),\n 'rnorm': lambda : NormLayerParser(NormLayerParser.RESPONSE_NORM),\n 'cnorm': lambda : NormLayerParser(NormLayerParser.CONTRAST_NORM),\n 'cmrnorm': lambda : NormLayerParser(NormLayerParser.CROSSMAP_RESPONSE_NORM),\n 'nailbed': lambda : NailbedLayerParser(),\n 'blur': lambda : GaussianBlurLayerParser(),\n 'href': lambda : HorizontalReflectionLayerParser(),\n 'resize': lambda : ResizeLayerParser(),\n 'rgb2yuv': lambda : RGBToYUVLayerParser(),\n 'rgb2lab': lambda : RGBToLABLayerParser(),\n 'rscale': lambda : RandomScaleLayerParser(),\n 'crop': lambda : CropLayerParser(),\n 'concat': lambda : ConcatentionLayerParser(),\n 'pass': lambda : PassThroughLayerParser(),\n 'dropout': lambda : DropoutLayerParser(),\n 'dropout2': lambda : Dropout2LayerParser(),\n 'cost.logreg': lambda : LogregCostParser(),\n 'cost.crossent': lambda : CrossEntCostParser(),\n 'cost.bce': lambda : BinomialCrossEntCostParser(),\n 'cost.dce': lambda : DetectionCrossEntCostParser(),\n 'cost.sum2': lambda : SumOfSquaresCostParser()}\n \n# All the neuron parsers\n# This isn't a name --> parser mapping as the layer parsers above because neurons don't have fixed names.\n# A user may write tanh[0.5,0.25], etc.\nneuron_parsers = sorted([NeuronParser('ident', 'f(x) = x', uses_acts=False, uses_inputs=False),\n NeuronParser('logistic', 'f(x) = 1 / (1 + e^-x)', uses_acts=True, uses_inputs=False),\n NeuronParser('abs', 'f(x) = |x|', uses_acts=False, uses_inputs=True),\n NeuronParser('relu', 'f(x) = max(0, x)', uses_acts=True, uses_inputs=False),\n NeuronParser('nrelu', 'f(x) = max(0, x) + noise', uses_acts=True, uses_inputs=False),\n NeuronParser('softrelu', 'f(x) = log(1 + e^x)', uses_acts=True, uses_inputs=False),\n NeuronParser('square', 'f(x) = x^2', uses_acts=False, uses_inputs=True),\n NeuronParser('sqrt', 'f(x) = sqrt(x)', uses_acts=True, uses_inputs=False),\n ParamNeuronParser('log[a]', 'f(x) = log(a + x)', uses_acts=False, uses_inputs=True),\n ParamNeuronParser('tanh[a,b]', 'f(x) = a * tanh(b * x)', uses_acts=True, uses_inputs=False),\n ParamNeuronParser('brelu[a]', 'f(x) = min(a, max(0, x))', uses_acts=True, uses_inputs=False),\n ParamNeuronParser('linear[a,b]', 'f(x) = a * x + b', uses_acts=True, uses_inputs=False),\n ParamNeuronParser('drelu[a]', 'f(x) = x - a * tanh(x / a)', uses_acts=False, uses_inputs=True)],\n key=lambda x:x.type)\n\n# Learning rate schedules\nlrs_parsers = sorted([ParamParser('const[fbase]'),\n ParamParser('linear[fbase;ftgtFactor]'),\n ParamParser('exp[fbase;ftgtFactor]'),\n ParamParser('dexp[fbase;ftgtFactor;inumSteps]')])\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-cifar10-11pct.cfg", "content": "# 11% error on CIFAR-10 - layer parameter file\n# Methodology:\n# 1. Train on batches 1-4, use batch 5 for validation.\n# 2. After about 350 epochs, validation error no longer making improvements.\n# 3. Fold in batch 5.\n# 4. Train on batches 1-5 for about 150 more epochs, until the batch 5 error is near the errors for batches 1-4. It takes forever to actually get there but after 150 epochs it's close enough.\n# 5. Lower learning rates (epsW) by a factor of 10 to 0.0001, train for 10 more epochs.\n# 6. Lower learning rates (epsW) by another factor of 10 to 0.00001, train for 10 more epochs.\n# 7. Stop. Test on batch 6 with --test-range=6 --multiview-test=1 --logreg-name=logprob (read more about what this does here: http://code.google.com/p/cuda-convnet/wiki/TrainingNet#Training_on_image_translations )\n\n# More details about methodology: http://code.google.com/p/cuda-convnet/wiki/Methodology\n\n[conv1]\nepsW=0.001\nepsB=0.002\nmomW=0.9\nmomB=0.9\nwc=0.000\n\n[conv2]\nepsW=0.001\nepsB=0.002\nmomW=0.9\nmomB=0.9\nwc=0.000\n\n[local3]\nepsW=0.001\nepsB=0.002\nmomW=0.9\nmomB=0.9\nwc=0.004\n\n[local4]\nepsW=0.001\nepsB=0.002\nmomW=0.9\nmomB=0.9\nwc=0.004\n\n[fc10]\nepsW=0.001\nepsB=0.002\nmomW=0.9\nmomB=0.9\nwc=0.01\n\n[logprob]\ncoeff=1\n\n[rnorm1]\nscale=0.001\npow=0.75\n\n[rnorm2]\nscale=0.001\npow=0.75\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-1gpu.cfg", "content": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv3]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv4]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv5]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc4096a]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc4096b]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1000]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[logprob]\ncoeff=1\ntopk=5\n\n[dropout1]\nenable=true\n\n[dropout2]\nenable=true\n\n[rnorm1]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[rnorm2]\nscale=0.0001\npow=0.75\nminDiv=2\n\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-2gpu-data.cfg", "content": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv3]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv4]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv5]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc4096a]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc4096b]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1000]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[logprob]\ncoeff=1\ntopk=5\n\n[dropout1]\nenable=true\n\n[dropout2]\nenable=true\n\n[rnorm1]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[rnorm2]\nscale=0.0001\npow=0.75\nminDiv=2\n\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-2gpu-model.cfg", "content": "[conv1a]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\n\n\n[conv1b]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\n\n\n[conv2a]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\n\n\n[conv2b]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\n\n\n[conv3a]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9,0.9\nmomB=0.9\nwc=0.0005,0.0005\nwball=0,0\n\n\n\n[conv3b]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9,0.9\nmomB=0.9\nwc=0.0005,0.0005\nwball=0,0\n\n\n[conv4a]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\n\n\n[conv4b]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\n\n\n[conv5a]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\n\n\n[conv5b]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\n\n\n[fc2048a]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9,0.9\nmomB=0.9\nwc=0.0005,0.0005\nwball=0,0\n\n\n[fc2048b]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9,0.9\nmomB=0.9\nwc=0.0005,0.0005\nwball=0,0\n\n\n[fc2048ba]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9,0.9\nmomB=0.9\nwc=0.0005,0.0005\nwball=0,0\n\n\n[fc2048bb]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9,0.9\nmomB=0.9\nwc=0.0005,0.0005\nwball=0,0\n\n[fc1000]\nepsW=dexp[base=0.02;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.04;tgtFactor=25;numSteps=2]\nmomW=0.9,0.9\nmomB=0.9\nwc=0.0005,0.0005\nwball=0,0\n\n\n[logprob]\ncoeff=1\ntopk=5\n\n[dropout1a]\nenable=true\nkeep=0.5\n\n[dropout2a]\nenable=true\nkeep=0.5\n\n[dropout1b]\nenable=true\nkeep=0.5\n\n[dropout2b]\nenable=true\nkeep=0.5\n\n[rnorm1a]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[rnorm1b]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[rnorm2a]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[rnorm2b]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[cnorm2a]\nscale=0.001\npow=0.75\n\n[cnorm2b]\nscale=0.001\npow=0.75\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-4gpu-data-model.cfg", "content": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\n\n[conv2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\n\n[conv3]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\n\n[conv4]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\n\n[conv5]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\n\n[fc1024a]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1024b]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1024c]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1024d]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1024ba]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1024bb]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1024bc]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1024bd]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n\n[fc1000]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.01;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.02;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[logprob]\ncoeff=1\ntopk=5\n\n[dropout1a]\nenable=true\nkeep=0.5\n\n[dropout1b]\nenable=true\nkeep=0.5\n\n[dropout1c]\nenable=true\nkeep=0.5\n\n[dropout1d]\nenable=true\nkeep=0.5\n\n[dropout2a]\nenable=true\nkeep=0.5\n\n[dropout2b]\nenable=true\nkeep=0.5\n\n[dropout2c]\nenable=true\nkeep=0.5\n\n[dropout2d]\nenable=true\nkeep=0.5\n\n[rnorm1]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[rnorm2]\nscale=0.0001\npow=0.75\nminDiv=2\n\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layer-params-imagenet-4gpu-data.cfg", "content": "[conv1]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv2]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0.00\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv3]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv4]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[conv5]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc4096a]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc4096b]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[fc1000]\nmomW=0.9\nmomB=0.9\nwc=0.0005\nwball=0\nepsW=dexp[base=0.04;tgtFactor=250;numSteps=4]\nepsB=dexp[base=0.08;tgtFactor=10;numSteps=2]\nupdatePeriod=1\n\n[logprob]\ncoeff=1\ntopk=5\n\n[dropout1]\nenable=true\n\n[dropout2]\nenable=true\n\n[rnorm1]\nscale=0.0001\npow=0.75\nminDiv=2\n\n[rnorm2]\nscale=0.0001\npow=0.75\nminDiv=2\n\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layers-cifar10-11pct.cfg", "content": "[data]\ntype=data\ndataIdx=0\n\n[labels]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=2\nstride=1\nfilterSize=5\nneuron=relu\ninitW=0.0001\nsumWidth=4\nsharedBiases=1\ngpu=0\n\n[pool1]\ntype=pool\npool=max\ninputs=conv1\nstart=0\nsizeX=3\nstride=2\noutputsX=0\nchannels=64\n\n[rnorm1]\ntype=cmrnorm\ninputs=pool1\nchannels=64\nsize=9\n\n[conv2]\ntype=conv\ninputs=rnorm1\nfilters=64\npadding=2\nstride=1\nfilterSize=5\nchannels=64\nneuron=relu\ninitW=0.01\nsumWidth=2\nsharedBiases=1\n\n[rnorm2]\ntype=cmrnorm\ninputs=conv2\nchannels=64\nsize=9\n\n[pool2]\ntype=pool\npool=max\ninputs=rnorm2\nstart=0\nsizeX=3\nstride=2\noutputsX=0\nchannels=64\n\n[local3]\ntype=local\ninputs=pool2\nfilters=64\npadding=1\nstride=1\nfilterSize=3\nchannels=64\nneuron=relu\ninitW=0.04\n\n[local4]\ntype=local\ninputs=local3\nfilters=32\npadding=1\nstride=1\nfilterSize=3\nchannels=64\nneuron=relu\ninitW=0.04\n\n[fc10]\ntype=fc\noutputs=10\ninputs=local4\ninitW=0.01\n\n[probs]\ntype=softmax\ninputs=fc10\n\n[logprob]\ntype=cost.logreg\ninputs=labels,probs\ngpu=0\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-1gpu.cfg", "content": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\nstride=4\nfilterSize=11\ninitW=0.01\nsumWidth=4\nsharedBiases=1\ngpu=0\n\n[rnorm1]\ntype=cmrnorm\ninputs=conv1\nchannels=64\nsize=5\n\n[pool1]\ntype=pool\npool=max\ninputs=rnorm1\nsizeX=3\nstride=2\nchannels=64\nneuron=relu\n\n[conv2]\ntype=conv\ninputs=pool1\nfilters=192\npadding=2\nstride=1\nfilterSize=5\nchannels=64\ninitW=0.01\ninitB=1\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[rnorm2]\ntype=cmrnorm\ninputs=conv2\nchannels=192\nsize=5\n\n[pool2]\ntype=pool\npool=max\ninputs=rnorm2\nsizeX=3\nstride=2\nchannels=192\n\n[conv3]\ntype=conv\ninputs=pool2\nfilters=384\npadding=1\nstride=1\nfilterSize=3\nchannels=192\ninitW=0.03\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[conv4]\ntype=conv\ninputs=conv3\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=384\nneuron=relu\ninitW=0.03\ninitB=1\nsumWidth=3\nsharedBiases=1\n\n[conv5]\ntype=conv\ninputs=conv4\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=256\ninitW=0.03\ninitB=1\nsumWidth=3\n\n[pool3]\ntype=pool\npool=max\ninputs=conv5\nsizeX=3\nstride=2\nchannels=256\nneuron=relu\n\n[fc4096a]\ntype=fc\ninputs=pool3\noutputs=4096\ninitW=0.01\ninitB=1\nneuron=relu\ngpu=0\n\n[dropout1]\ntype=dropout2\ninputs=fc4096a\n\n[fc4096b]\ntype=fc\ninputs=dropout1\noutputs=4096\ninitW=0.01\ninitB=1\nneuron=relu\ngpu=0\n\n[dropout2]\ntype=dropout2\ninputs=fc4096b\n\n[fc1000]\ntype=fc\noutputs=1000\ninputs=dropout2\ninitW=0.01\ninitB=-7\ngpu=0\n\n[probs]\ntype=softmax\ninputs=fc1000\n\n[logprob]\ntype=cost.logreg\ninputs=labvec,probs\ngpu=0\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-2gpu-data.cfg", "content": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\nstride=4\nfilterSize=11\ninitW=0.01\nsumWidth=4\nsharedBiases=1\ngpu=0,1\n\n[rnorm1]\ntype=cmrnorm\ninputs=conv1\nchannels=64\nsize=5\n\n[pool1]\ntype=pool\npool=max\ninputs=rnorm1\nsizeX=3\nstride=2\nchannels=64\nneuron=relu\n\n[conv2]\ntype=conv\ninputs=pool1\nfilters=192\npadding=2\nstride=1\nfilterSize=5\nchannels=64\ninitW=0.01\ninitB=1\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[rnorm2]\ntype=cmrnorm\ninputs=conv2\nchannels=192\nsize=5\n\n[pool2]\ntype=pool\npool=max\ninputs=rnorm2\nsizeX=3\nstride=2\nchannels=192\n\n[conv3]\ntype=conv\ninputs=pool2\nfilters=384\npadding=1\nstride=1\nfilterSize=3\nchannels=192\ninitW=0.03\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[conv4]\ntype=conv\ninputs=conv3\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=384\nneuron=relu\ninitW=0.03\ninitB=1\nsumWidth=3\nsharedBiases=1\n\n[conv5]\ntype=conv\ninputs=conv4\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=256\ninitW=0.03\ninitB=1\nsumWidth=3\n\n[pool3]\ntype=pool\npool=max\ninputs=conv5\nsizeX=3\nstride=2\nchannels=256\nneuron=relu\n\n[fc4096a]\ntype=fc\ninputs=pool3\noutputs=4096\ninitW=0.01\ninitB=1\nneuron=relu\n\n[dropout1]\ntype=dropout2\ninputs=fc4096a\n\n[fc4096b]\ntype=fc\ninputs=dropout1\noutputs=4096\ninitW=0.01\ninitB=1\nneuron=relu\n\n[dropout2]\ntype=dropout2\ninputs=fc4096b\n\n[fc1000]\ntype=fc\noutputs=1000\ninputs=dropout2\ninitW=0.01\ninitB=-7\n\n[probs]\ntype=softmax\ninputs=fc1000\n\n[logprob]\ntype=cost.logreg\ninputs=labvec,probs\ngpu=0,1\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-2gpu-model.cfg", "content": "[data]\ntype=data\ndataIdx=0\n\n[labels]\ntype=data\ndataIdx=1\n\n[conv1a]\ntype=conv\ninputs=data\nchannels=3\nfilters=48\npadding=0\nstride=4\nfilterSize=11\ninitW=0.01\nsumWidth=3\nsharedBiases=1\ngpu=0\n\n[conv1b]\ntype=conv\ninputs=data\nchannels=3\nfilters=48\npadding=0\nstride=4\nfilterSize=11\ninitW=0.01\nsumWidth=3\nsharedBiases=1\ngpu=1\n\n[rnorm1a]\ntype=cmrnorm\ninputs=conv1a\nchannels=48\nsize=5\n\n[rnorm1b]\ntype=cmrnorm\ninputs=conv1b\nchannels=48\nsize=5\n\n[pool1a]\ntype=pool\npool=max\ninputs=rnorm1a\nsizeX=3\nstride=2\nchannels=48\nneuron=relu\n\n[pool1b]\ntype=pool\npool=max\ninputs=rnorm1b\nsizeX=3\nstride=2\nchannels=48\nneuron=relu\n\n[conv2a]\ntype=conv\ninputs=pool1a\nfilters=128\npadding=2\nstride=1\nfilterSize=5\nchannels=48\ninitW=0.01\ninitB=1\nsumWidth=3\nsharedBiases=1\nneuron=relu\ngpu=0\n\n[conv2b]\ntype=conv\ninputs=pool1b\nfilters=128\npadding=2\nstride=1\nfilterSize=5\nchannels=48\ninitW=0.01\ninitB=1\nsumWidth=3\nsharedBiases=1\nneuron=relu\ngpu=1\n\n[rnorm2a]\ntype=cmrnorm\ninputs=conv2a\nchannels=128\nsize=5\n\n[rnorm2b]\ntype=cmrnorm\ninputs=conv2b\nchannels=128\nsize=5\n\n[cnorm2a]\ntype=rnorm\ninputs=rnorm2a\nchannels=128\nsize=5\n\n[cnorm2b]\ntype=rnorm\ninputs=rnorm2b\nchannels=128\nsize=5\n\n[pool2a]\ntype=pool\npool=max\ninputs=cnorm2a\nsizeX=3\nstride=2\nchannels=128\n\n[pool2b]\ntype=pool\npool=max\ninputs=cnorm2b\nsizeX=3\nstride=2\nchannels=128\n\n[conv3a]\ntype=conv\ninputs=pool2a,pool2b\nfilters=192,192\npadding=1,1\nstride=1,1\nfilterSize=3,3\nchannels=128,128\ninitW=0.03,0.03\nsumWidth=2\nsharedBiases=1\nneuron=relu\ngpu=0\n\n[conv3b]\ntype=conv\ninputs=pool2a,pool2b\nfilters=192,192\npadding=1,1\nstride=1,1\nfilterSize=3,3\nchannels=128,128\ninitW=0.03,0.03\nsumWidth=2\nsharedBiases=1\nneuron=relu\ngpu=1\n\n[conv4a]\ntype=conv\ninputs=conv3a\nfilters=192\npadding=1\nstride=1\nfilterSize=3\nchannels=192\nneuron=relu\ninitW=0.03\ninitB=1\nsumWidth=2\nsharedBiases=1\n\n[conv4b]\ntype=conv\ninputs=conv3b\nfilters=192\npadding=1\nstride=1\nfilterSize=3\nchannels=192\nneuron=relu\ninitW=0.03\ninitB=1\nsumWidth=2\nsharedBiases=1\n\n\n[conv5a]\ntype=conv\ninputs=conv4a\nfilters=128\npadding=1\nstride=1\nfilterSize=3\nchannels=192\ninitW=0.03\ninitB=1\nsumWidth=2\ngroups=1\nrandSparse=0\n\n[conv5b]\ntype=conv\ninputs=conv4b\nfilters=128\npadding=1\nstride=1\nfilterSize=3\nchannels=192\ninitW=0.03\ninitB=1\nsumWidth=2\ngroups=1\nrandSparse=0\n\n[pool3a]\ntype=pool\npool=max\ninputs=conv5a\nsizeX=3\nstride=2\nchannels=128\nneuron=relu\n\n[pool3b]\ntype=pool\npool=max\ninputs=conv5b\nsizeX=3\nstride=2\nchannels=128\nneuron=relu\n\n[fc2048a]\ntype=fc\ninputs=pool3a,pool3b\noutputs=2048\ninitW=0.01,0.01\ninitB=1\nneuron=relu\ngpu=0\n\n[fc2048b]\ntype=fc\ninputs=pool3a,pool3b\noutputs=2048\ninitW=0.01,0.01\ninitB=1\nneuron=relu\ngpu=1\n\n[dropout1a]\ntype=dropout\ninputs=fc2048a\n\n[dropout1b]\ntype=dropout\ninputs=fc2048b\n\n[fc2048ba]\ntype=fc\ninputs=dropout1a,dropout1b\noutputs=2048\ninitW=0.01,0.01\ninitB=1\nneuron=relu\ngpu=0\n\n[fc2048bb]\ntype=fc\ninputs=dropout1b,dropout1a\noutputs=2048\ninitW=0.01,0.01\ninitB=1\nneuron=relu\ngpu=1\n\n[dropout2a]\ntype=dropout\ninputs=fc2048ba\n\n[dropout2b]\ntype=dropout\ninputs=fc2048bb\n\n[fc1000]\ntype=fc\noutputs=1000\ninputs=dropout2a,dropout2b\ninitW=0.01,0.01\ngpu=0\n\n[probs]\ntype=softmax\ninputs=fc1000\n\n[logprob]\ntype=cost.logreg\ninputs=labels,probs\ngpu=0\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-4gpu-data-model.cfg", "content": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\nstride=4\nfilterSize=11\ninitW=0.01\nsumWidth=4\nsharedBiases=1\ngpu=0,1,2,3\n\n[rnorm1]\ntype=cmrnorm\ninputs=conv1\nchannels=64\nsize=5\n\n[pool1]\ntype=pool\npool=max\ninputs=rnorm1\nsizeX=3\nstride=2\nchannels=64\nneuron=relu\n\n[conv2]\ntype=conv\ninputs=pool1\nfilters=192\npadding=2\nstride=1\nfilterSize=5\nchannels=64\ninitW=0.01\ninitB=1\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[rnorm2]\ntype=cmrnorm\ninputs=conv2\nchannels=192\nsize=5\n\n[pool2]\ntype=pool\npool=max\ninputs=rnorm2\nsizeX=3\nstride=2\nchannels=192\n\n[conv3]\ntype=conv\ninputs=pool2\nfilters=384\npadding=1\nstride=1\nfilterSize=3\nchannels=192\ninitW=0.03\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[conv4]\ntype=conv\ninputs=conv3\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=384\nneuron=relu\ninitW=0.03\ninitB=1\nsumWidth=3\nsharedBiases=1\n\n[conv5]\ntype=conv\ninputs=conv4\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=256\ninitW=0.03\ninitB=1\nsumWidth=3\n\n[pool3]\ntype=pool\npool=max\ninputs=conv5\nsizeX=3\nstride=2\nchannels=256\nneuron=relu\n\n[fc1024a]\ntype=fc\ninputs=pool3\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\ngpu=0\n\n[fc1024b]\ntype=fc\ninputs=pool3\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\ngpu=1\n\n[fc1024c]\ntype=fc\ninputs=pool3\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\ngpu=2\n\n[fc1024d]\ntype=fc\ninputs=pool3\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\ngpu=3\n\n[dropout1a]\ntype=dropout2\ninputs=fc1024a\n\n[dropout1b]\ntype=dropout2\ninputs=fc1024b\n\n[dropout1c]\ntype=dropout2\ninputs=fc1024c\n\n[dropout1d]\ntype=dropout2\ninputs=fc1024d\n\n# This is like a concatenation layer\n[pass1a]\ntype=pass\ninputs=dropout1a,dropout1b,dropout1c,dropout1d\ngpu=0\n\n# This is like a concatenation layer\n[pass1b]\ntype=pass\ninputs=dropout1a,dropout1b,dropout1c,dropout1d\ngpu=1\n\n# This is like a concatenation layer\n[pass1c]\ntype=pass\ninputs=dropout1a,dropout1b,dropout1c,dropout1d\ngpu=2\n\n# This is like a concatenation layer\n[pass1d]\ntype=pass\ninputs=dropout1a,dropout1b,dropout1c,dropout1d\ngpu=3\n\n\n[fc1024ba]\ntype=fc\ninputs=pass1a\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\n\n[fc1024bb]\ntype=fc\ninputs=pass1b\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\n\n[fc1024bc]\ntype=fc\ninputs=pass1c\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\n\n[fc1024bd]\ntype=fc\ninputs=pass1d\noutputs=1024\ninitW=0.01\ninitB=1\nneuron=relu\n\n[dropout2a]\ntype=dropout2\ninputs=fc1024ba\n\n[dropout2b]\ntype=dropout2\ninputs=fc1024bb\n\n[dropout2c]\ntype=dropout2\ninputs=fc1024bc\n\n[dropout2d]\ntype=dropout2\ninputs=fc1024bd\n\n[pass2a]\ninputs=dropout2a,dropout2b,dropout2c,dropout2d\ntype=pass\ngpu=0\n\n[fc1000]\ntype=fc\noutputs=1000\ninputs=pass2a\ninitW=0.01\n\n[probs]\ntype=softmax\ninputs=fc1000\n\n[logprob]\ntype=cost.logreg\ninputs=labvec,probs\ngpu=0\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/layers/layers-imagenet-4gpu-data.cfg", "content": "[data]\ntype=data\ndataIdx=0\n\n[labvec]\ntype=data\ndataIdx=1\n\n[conv1]\ntype=conv\ninputs=data\nchannels=3\nfilters=64\npadding=0\nstride=4\nfilterSize=11\ninitW=0.01\nsumWidth=4\nsharedBiases=1\ngpu=0,1,2,3\n\n[rnorm1]\ntype=cmrnorm\ninputs=conv1\nchannels=64\nsize=5\n\n[pool1]\ntype=pool\npool=max\ninputs=rnorm1\nsizeX=3\nstride=2\nchannels=64\nneuron=relu\n\n[conv2]\ntype=conv\ninputs=pool1\nfilters=192\npadding=2\nstride=1\nfilterSize=5\nchannels=64\ninitW=0.01\ninitB=1\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[rnorm2]\ntype=cmrnorm\ninputs=conv2\nchannels=192\nsize=5\n\n[pool2]\ntype=pool\npool=max\ninputs=rnorm2\nsizeX=3\nstride=2\nchannels=192\n\n[conv3]\ntype=conv\ninputs=pool2\nfilters=384\npadding=1\nstride=1\nfilterSize=3\nchannels=192\ninitW=0.03\nsumWidth=3\nsharedBiases=1\nneuron=relu\n\n[conv4]\ntype=conv\ninputs=conv3\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=384\nneuron=relu\ninitW=0.03\ninitB=1\nsumWidth=3\nsharedBiases=1\n\n[conv5]\ntype=conv\ninputs=conv4\nfilters=256\npadding=1\nstride=1\nfilterSize=3\nchannels=256\ninitW=0.03\ninitB=1\nsumWidth=3\n\n[pool3]\ntype=pool\npool=max\ninputs=conv5\nsizeX=3\nstride=2\nchannels=256\nneuron=relu\n\n[fc4096a]\ntype=fc\ninputs=pool3\noutputs=4096\ninitW=0.01\ninitB=1\nneuron=relu\n\n[dropout1]\ntype=dropout2\ninputs=fc4096a\n\n[fc4096b]\ntype=fc\ninputs=dropout1\noutputs=4096\ninitW=0.01\ninitB=1\nneuron=relu\n\n[dropout2]\ntype=dropout2\ninputs=fc4096b\n\n[fc1000]\ntype=fc\noutputs=1000\ninputs=dropout2\ninitW=0.01\ninitB=-7\n\n[probs]\ntype=softmax\ninputs=fc1000\n\n[logprob]\ntype=cost.logreg\ninputs=labvec,probs\ngpu=0,1,2,3\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/make-data/make-data.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#################################################################################\n\n\n# This script makes batches suitable for training from raw ILSVRC 2012 tar files.\n\nimport tarfile\nfrom StringIO import StringIO\nfrom random import shuffle\nimport sys\nfrom time import time\nfrom pyext._MakeDataPyExt import resizeJPEG\nimport itertools\nimport os\nimport cPickle\nimport scipy.io\nimport math\nimport argparse as argp\n\n# Set this to True to crop images to square. In this case each image will be\n# resized such that its shortest edge is OUTPUT_IMAGE_SIZE pixels, and then the\n# center OUTPUT_IMAGE_SIZE x OUTPUT_IMAGE_SIZE patch will be extracted.\n#\n# Set this to False to preserve image borders. In this case each image will be\n# resized such that its shortest edge is OUTPUT_IMAGE_SIZE pixels. This was\n# demonstrated to be superior by Andrew Howard in his very nice paper:\n# http://arxiv.org/abs/1312.5402\nCROP_TO_SQUARE = True\nOUTPUT_IMAGE_SIZE = 256\n\n# Number of threads to use for JPEG decompression and image resizing.\nNUM_WORKER_THREADS = 8\n\n# Don't worry about these.\nOUTPUT_BATCH_SIZE = 3072\nOUTPUT_SUB_BATCH_SIZE = 1024\n\ndef pickle(filename, data):\n with open(filename, \"w\") as fo:\n cPickle.dump(data, fo, protocol=cPickle.HIGHEST_PROTOCOL)\n\ndef unpickle(filename):\n fo = open(filename, 'r')\n contents = cPickle.load(fo)\n fo.close()\n return contents\n\ndef partition_list(l, partition_size):\n divup = lambda a,b: (a + b - 1) / b\n return [l[i*partition_size:(i+1)*partition_size] for i in xrange(divup(len(l),partition_size))]\n\ndef open_tar(path, name):\n if not os.path.exists(path):\n print \"ILSVRC 2012 %s not found at %s. Make sure to set ILSVRC_SRC_DIR correctly at the top of this file (%s).\" % (name, path, sys.argv[0])\n sys.exit(1)\n return tarfile.open(path)\n\ndef makedir(path):\n if not os.path.exists(path):\n os.makedirs(path)\n\ndef parse_devkit_meta(ILSVRC_DEVKIT_TAR):\n tf = open_tar(ILSVRC_DEVKIT_TAR, 'devkit tar')\n fmeta = tf.extractfile(tf.getmember('ILSVRC2012_devkit_t12/data/meta.mat'))\n meta_mat = scipy.io.loadmat(StringIO(fmeta.read()))\n labels_dic = dict((m[0][1][0], m[0][0][0][0]-1) for m in meta_mat['synsets'] if m[0][0][0][0] >= 1 and m[0][0][0][0] <= 1000)\n label_names_dic = dict((m[0][1][0], m[0][2][0]) for m in meta_mat['synsets'] if m[0][0][0][0] >= 1 and m[0][0][0][0] <= 1000)\n label_names = [tup[1] for tup in sorted([(v,label_names_dic[k]) for k,v in labels_dic.items()], key=lambda x:x[0])]\n\n fval_ground_truth = tf.extractfile(tf.getmember('ILSVRC2012_devkit_t12/data/ILSVRC2012_validation_ground_truth.txt'))\n validation_ground_truth = [[int(line.strip()) - 1] for line in fval_ground_truth.readlines()]\n tf.close()\n return labels_dic, label_names, validation_ground_truth\n\ndef write_batches(target_dir, name, start_batch_num, labels, jpeg_files):\n jpeg_files = partition_list(jpeg_files, OUTPUT_BATCH_SIZE)\n labels = partition_list(labels, OUTPUT_BATCH_SIZE)\n makedir(target_dir)\n print \"Writing %s batches...\" % name\n for i,(labels_batch, jpeg_file_batch) in enumerate(zip(labels, jpeg_files)):\n t = time()\n jpeg_strings = list(itertools.chain.from_iterable(resizeJPEG([jpeg.read() for jpeg in jpeg_file_batch], OUTPUT_IMAGE_SIZE, NUM_WORKER_THREADS, CROP_TO_SQUARE)))\n batch_path = os.path.join(target_dir, 'data_batch_%d' % (start_batch_num + i))\n makedir(batch_path)\n for j in xrange(0, len(labels_batch), OUTPUT_SUB_BATCH_SIZE):\n pickle(os.path.join(batch_path, 'data_batch_%d.%d' % (start_batch_num + i, j/OUTPUT_SUB_BATCH_SIZE)), \n {'data': jpeg_strings[j:j+OUTPUT_SUB_BATCH_SIZE],\n 'labels': labels_batch[j:j+OUTPUT_SUB_BATCH_SIZE]})\n print \"Wrote %s (%s batch %d of %d) (%.2f sec)\" % (batch_path, name, i+1, len(jpeg_files), time() - t)\n return i + 1\n\nif __name__ == \"__main__\":\n parser = argp.ArgumentParser()\n parser.add_argument('--src-dir', help='Directory containing ILSVRC2012_img_train.tar, ILSVRC2012_img_val.tar, and ILSVRC2012_devkit_t12.tar.gz', required=True)\n parser.add_argument('--tgt-dir', help='Directory to output ILSVRC 2012 batches suitable for cuda-convnet to train on.', required=True)\n args = parser.parse_args()\n \n print \"CROP_TO_SQUARE: %s\" % CROP_TO_SQUARE\n print \"OUTPUT_IMAGE_SIZE: %s\" % OUTPUT_IMAGE_SIZE\n print \"NUM_WORKER_THREADS: %s\" % NUM_WORKER_THREADS\n\n ILSVRC_TRAIN_TAR = os.path.join(args.src_dir, 'ILSVRC2012_img_train.tar')\n ILSVRC_VALIDATION_TAR = os.path.join(args.src_dir, 'ILSVRC2012_img_val.tar')\n ILSVRC_DEVKIT_TAR = os.path.join(args.src_dir, 'ILSVRC2012_devkit_t12.tar.gz')\n\n assert OUTPUT_BATCH_SIZE % OUTPUT_SUB_BATCH_SIZE == 0\n labels_dic, label_names, validation_labels = parse_devkit_meta(ILSVRC_DEVKIT_TAR)\n\n with open_tar(ILSVRC_TRAIN_TAR, 'training tar') as tf:\n synsets = tf.getmembers()\n synset_tars = [tarfile.open(fileobj=tf.extractfile(s)) for s in synsets]\n print \"Loaded synset tars.\"\n print \"Building training set image list (this can take 10-20 minutes)...\"\n sys.stdout.flush()\n \n train_jpeg_files = []\n for i,st in enumerate(synset_tars):\n if i % 100 == 0:\n print \"%d%% ...\" % int(round(100.0 * float(i) / len(synset_tars))),\n sys.stdout.flush()\n train_jpeg_files += [st.extractfile(m) for m in st.getmembers()]\n st.close()\n \n shuffle(train_jpeg_files)\n train_labels = [[labels_dic[jpeg.name[:9]]] for jpeg in train_jpeg_files]\n print \"done\"\n \n # Write training batches\n i = write_batches(args.tgt_dir, 'training', 0, train_labels, train_jpeg_files)\n \n # Write validation batches\n val_batch_start = int(math.ceil((i / 1000.0))) * 1000\n with open_tar(ILSVRC_VALIDATION_TAR, 'validation tar') as tf:\n validation_jpeg_files = sorted([tf.extractfile(m) for m in tf.getmembers()], key=lambda x:x.name)\n write_batches(args.tgt_dir, 'validation', val_batch_start, validation_labels, validation_jpeg_files)\n \n # Write meta file\n meta = unpickle('input_meta')\n meta_file = os.path.join(args.tgt_dir, 'batches.meta')\n meta.update({'batch_size': OUTPUT_BATCH_SIZE,\n 'num_vis': OUTPUT_IMAGE_SIZE**2 * 3,\n 'label_names': label_names})\n pickle(meta_file, meta)\n print \"Wrote %s\" % meta_file\n print \"All done! ILSVRC 2012 batches are in %s\" % args.tgt_dir\n" }, { "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/Makefile", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nINCLUDES := -I./include\nCOMMONFLAGS :=\nCC_ARGS := \n\nifndef debug\n\tCC_ARGS += -O3\nendif\nCC=g++\n\nOUT_DIR=./bin/$(OUT_SUFFIX)\n\nPYTHON_VERSION=$(shell python -V 2>&1 | cut -d ' ' -f 2 | cut -d '.' -f 1,2)\nLINK_LIBS := -L$(CUDA_INSTALL_PATH)/lib64 `pkg-config --libs python` `pkg-config --libs opencv` -lpthread\n\nINCLUDES += -I$(PYTHON_INCLUDE_PATH) \nOUT_FILE=_MakeDataPyExt.so\n\nall: dir classes $(OUT_FILE)\n\ndir:\n\tmkdir -p $(OUT_DIR)/src\n\nSOURCES = $(shell echo src/*.cpp)\nCLASSES = $(SOURCES:.cpp=.o)\n\nclasses: $(CLASSES)\n\n%.o: %.cpp\n\t$(CC) $(CC_ARGS) -c -fPIC $(BUILD_ARGS) $(COMMONFLAGS) $(INCLUDES) $< -o $(OUT_DIR)/$*.o\n\n$(OUT_FILE): classes\n\tcd $(OUT_DIR) && $(CC) $(CC_ARGS) $(BUILD_ARGS) $(COMMONFLAGS) -shared -Wl,-no-undefined -o $(OUT_FILE) $(CLASSES) $(LINK_LIBS)\n\tln -sf $(OUT_DIR)/$(OUT_FILE) .\n\nclean:\n\trm -rf $(OUT_DIR)/*\n" }, { "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/__init__.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License." }, { "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/include/pyext.h", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef INCLUDE_PYEXT_H_\n#define INCLUDE_PYEXT_H_\n\n#include \n//#include \n#include \n#include \n#include \"../../../util/include/thread.h\"\n\n#define JPEG_QUALITY 95\n\n#ifndef DIVUP\n#define DIVUP(a,b) (((a) + (b) - 1) / (b))\n#endif\n\nextern \"C\" {\n void init_MakeDataPyExt();\n}\nPyObject* resizeJPEG(PyObject *self, PyObject *args);\n\nclass DecoderThread : public Thread {\n protected:\n PyObject* _py_list_src;\n PyObject* _py_list_tgt;\n int _start_img, _end_img;\n int _target_size;\n bool _crop_to_square;\n\n cv::Mat _resized_mat_buffer;\n std::vector _output_jpeg_buffer;\n std::vector _encode_params;\n\n void* run();\n void makeJPEG(int idx);\n\n public:\n DecoderThread(PyObject* py_list_src, int start_img, int end_img, int target_size, bool crop_to_square);\n virtual ~DecoderThread();\n PyObject* getTargetList();\n};\n\n\n#endif // INCLUDE_PYEXT_H_\n" }, { "path": "caffe2/contrib/cuda-convnet2/make-data/pyext/src/pyext.cpp", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/pyext.h\"\n\nusing namespace std;\n\nstatic PyMethodDef _MakeDataPyExtMethods[] = {{ \"resizeJPEG\", resizeJPEG, METH_VARARGS },\n { NULL, NULL }\n};\n\nvoid init_MakeDataPyExt() {\n (void) Py_InitModule(\"_MakeDataPyExt\", _MakeDataPyExtMethods);\n}\n\nPyObject* resizeJPEG(PyObject *self, PyObject *args) {\n\n PyListObject* pyListSrc;\n int tgtImgSize, numThreads;\n int cropToSquare;\n\n if (!PyArg_ParseTuple(args, \"O!iii\",\n &PyList_Type, &pyListSrc,\n &tgtImgSize,\n &numThreads,\n &cropToSquare)) {\n return NULL;\n }\n\n DecoderThread* threads[numThreads];\n int num_imgs = PyList_GET_SIZE(pyListSrc);\n int num_imgs_per_thread = DIVUP(num_imgs, numThreads);\n for (int t = 0; t < numThreads; ++t) {\n int start_img = t * num_imgs_per_thread;\n int end_img = min(num_imgs, (t+1) * num_imgs_per_thread);\n\n threads[t] = new DecoderThread((PyObject*)pyListSrc, start_img, end_img, tgtImgSize, cropToSquare);\n threads[t]->start();\n }\n\n PyObject* pyListTgt = PyList_New(0);\n for (int t = 0; t < numThreads; ++t) {\n threads[t]->join();\n PyList_Append(pyListTgt, threads[t]->getTargetList());\n delete threads[t]; // the thread's list too\n }\n\n return pyListTgt;\n}\n\nDecoderThread::DecoderThread(PyObject* py_list_src, int start_img, int end_img, int target_size, bool crop_to_square)\n: Thread(true), _py_list_src(py_list_src), _start_img(start_img), _end_img(end_img), _target_size(target_size), _crop_to_square(crop_to_square) {\n\n _encode_params.push_back(CV_IMWRITE_JPEG_QUALITY);\n _encode_params.push_back(JPEG_QUALITY);\n _py_list_tgt = PyList_New(0);\n}\n\nDecoderThread::~DecoderThread(){\n Py_DECREF(_py_list_tgt);\n}\n\nvoid* DecoderThread::run() {\n for (int i = _start_img; i < _end_img; ++i) {\n makeJPEG(i);\n }\n return NULL;\n}\n\nPyObject* DecoderThread::getTargetList() {\n return _py_list_tgt;\n}\n\nvoid DecoderThread::makeJPEG(int idx) {\n /*\n * Decompress JPEG\n */\n PyObject* pySrc = PyList_GET_ITEM(_py_list_src, idx);\n uchar* src = (unsigned char*)PyString_AsString(pySrc);\n size_t src_len = PyString_GET_SIZE(pySrc);\n vector src_vec(src, src + src_len);\n\n cv::Mat decoded_mat = cv::imdecode(cv::Mat(src_vec), CV_LOAD_IMAGE_COLOR);\n assert(decoded_mat.channels() == 3);\n\n /*\n * Resize\n */\n double min_dim = std::min(decoded_mat.size().height, decoded_mat.size().width);\n double scale_factor = _target_size / min_dim;\n\n int new_height = round(scale_factor * decoded_mat.size().height);\n int new_width = round(scale_factor * decoded_mat.size().width);\n assert((new_height == _target_size && new_width >= _target_size)\n || (new_width == _target_size && new_height >= _target_size));\n int interpolation = scale_factor == 1 ? cv::INTER_LINEAR\n : scale_factor > 1 ? cv::INTER_CUBIC : cv::INTER_AREA;\n\n cv::resize(decoded_mat, _resized_mat_buffer, cv::Size(new_width, new_height), 0, 0, interpolation);\n\n /*\n * Conditionally crop and compress JPEG\n */\n if (_crop_to_square) {\n int crop_start_x = (new_width - _target_size) / 2;\n int crop_start_y = (new_height - _target_size) / 2;\n cv::Rect cropRect(crop_start_x, crop_start_y, _target_size, _target_size);\n cv::Mat cropped_mat_buffer = _resized_mat_buffer(cropRect);\n cv::imencode(\".jpg\", cropped_mat_buffer, _output_jpeg_buffer, _encode_params);\n } else {\n cv::imencode(\".jpg\", _resized_mat_buffer, _output_jpeg_buffer, _encode_params);\n }\n\n char* output_jpeg_buffer_ptr = reinterpret_cast(&_output_jpeg_buffer[0]);\n PyObject* pyStr = PyString_FromStringAndSize(output_jpeg_buffer_ptr, _output_jpeg_buffer.size());\n PyList_Append(_py_list_tgt, pyStr);\n Py_DECREF(pyStr);\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/Makefile", "content": "################################################################################\n#\n# Copyright 1993-2012 NVIDIA Corporation. All rights reserved.\n#\n# NOTICE TO USER: \n#\n# This source code is subject to NVIDIA ownership rights under U.S. and \n# international Copyright laws. \n#\n# NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE \n# CODE FOR ANY PURPOSE. IT IS PROVIDED \"AS IS\" WITHOUT EXPRESS OR \n# IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH \n# REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF \n# MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. \n# IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, \n# OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS \n# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE \n# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE \n# OR PERFORMANCE OF THIS SOURCE CODE. \n#\n# U.S. Government End Users. This source code is a \"commercial item\" as \n# that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of \n# \"commercial computer software\" and \"commercial computer software \n# documentation\" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) \n# and is provided to the U.S. Government only as a commercial end item. \n# Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through \n# 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the \n# source code with only those rights set forth herein.\n#\n################################################################################\n\n# Location of the CUDA Toolkit binaries and libraries\nCUDA_INC_PATH = $(CUDA_INSTALL_PATH)/include\nCUDA_BIN_PATH = $(CUDA_INSTALL_PATH)/bin\nCUDA_LIB_PATH = $(CUDA_INSTALL_PATH)/lib64\n\n# Common binaries\nNVCC = $(CUDA_BIN_PATH)/nvcc\nGCC = g++\nAR\t\t\t\t= ar\n\n# CUDA code generation flags\nGENCODE_SM35 := -gencode arch=compute_35,code=sm_35\nGENCODE_FLAGS := $(GENCODE_SM35)\n\nLDFLAGS := -L$(CUDA_LIB_PATH) -lcudart\nCCFLAGS := -m64\nNVCCFLAGS := -m64\n\n# Debug build flags\nifeq ($(dbg),1)\n CCFLAGS += -g\n NVCCFLAGS += -g -G\n DBG := debug\nelse\n DBG := release\n NVCCFLAGS += -O3\n CCFLAGS += -O3\nendif\n\n# Add profiler output\nifeq ($(prof),1)\n\tNVCCFLAGS += --ptxas-options=-v\nendif\n\nTARGETDIR := ./bin/$(DBG)\nOBJDIR := ./obj/$(DBG)\n\n########## USER STUFF ###########\nLDFLAGS \t\t+= -L../util -lutilpy -lcublas\nINCLUDES \t:= -I$(CUDA_INC_PATH) -I $(CUDA_SDK_PATH)/common/inc -I./include\n\nCUFILES\t:= $(shell find . -name \"*.cu\")\nCU_DEPS\t:= $(shell find . -name \"*.cuh\")\nCCFILES\t:= $(shell find . -name \"*.cpp\")\nC_DEPS\t:= $(shell find . -name \"*.h\")\n\nNVCCFLAGS += --compiler-options '-fPIC'\nLDFLAGS += -shared\nCCFLAGS += -fPIC\nTARGET := $(TARGETDIR)/libnvmatrix.so\n\n################################################################################\n# Set up target and object files\n################################################################################\nOBJS += $(patsubst %.cpp,$(OBJDIR)/%.cpp.o,$(CCFILES))\nOBJS += $(patsubst %.c,$(OBJDIR)/%.c.o,$(CFILES))\nOBJS += $(patsubst %.cu,$(OBJDIR)/%.cu.o,$(CUFILES))\n\n# Target rules\nall: makedirs $(TARGET)\n\n$(OBJDIR)/%.cu.o : %.cu $(CU_DEPS)\n\t$(NVCC) $(NVCCFLAGS) $(GENCODE_FLAGS) $(INCLUDES) -o $@ -c $<\n\n$(OBJDIR)/%.cpp.o : %.cpp $(C_DEPS)\n\t$(GCC) $(CCFLAGS) $(INCLUDES) -o $@ -c $<\n\n$(TARGET): $(OBJS)\n\t$(GCC) $(CCFLAGS) -o $@ $+ $(LDFLAGS)\n\tln -sf $(TARGET) .\n\nmakedirs:\n\tmkdir -p $(TARGETDIR)\n\tmkdir -p $(OBJDIR)/src\n\nclean:\n\trm -rf ./obj\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/memory.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef MEMORY_CUH_H_\n#define MEMORY_CUH_H_\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \"../../util/include/sync.h\"\n#include \"nvmatrix_kernels.cuh\"\n\n#define GPU_ALLOC_FRACTION 0.95 // Take 95% of available GPU memory\n#define HOST_ALLOC_CHUNK (1UL << 32)\n#define SYNC_ON_FREE true\n#define BUCKET_TYPE unsigned int\n\n// Allocte memory from up to this many buckets higher than desired without subdividing\n#define BUCKET_DIVISION_THRESHOLD 1\n#define NUM_BUCKETS static_cast(sizeof(BUCKET_TYPE) * 8)\n#define CLZ(x) ((x) == 0 ? (NUM_BUCKETS) : __builtin_clz(x))\n#define CEIL_LOG2(x) (NUM_BUCKETS - CLZ(x)) // Ceiling of log base 2 of (x + 1)\n#define LOG_FIRST_BUCKET_SIZE 12\n#define FIRST_BUCKET_SIZE (1 << LOG_FIRST_BUCKET_SIZE) // First bucket is for 4K bytes\n#define GET_ALLOC_BUCKET(size) (CEIL_LOG2(((size) - 1) >> LOG_FIRST_BUCKET_SIZE))\n#define GET_DEALLOC_BUCKET(size) (CEIL_LOG2((size) >> (1 + LOG_FIRST_BUCKET_SIZE)))\n#define GET_BUCKET_SIZE(b) (1UL << (LOG_FIRST_BUCKET_SIZE + b))\n\n#define BUCKET_MASK(b) (1UL << (b))\n#define PREV_BUCKETS_MASK(b) (BUCKET_MASK(b) - 1)\n#define AVAILABLE_NEXT_MASK(b, buckets) ((buckets) & ~PREV_BUCKETS_MASK(b))\n\n/*\n * Returns the \"best-matching\" available bucket as defined by policy.\n * The two policies are:\n *\n * TAKE_FROM_BIGGEST = true: If a bucket in the range\n * b...{b + BUCKET_DIVISION_THRESHOLD} is available, return the smallest\n * available bucket in that range. Otherwise return the *biggest* available\n * bucket greater than or equal to b.\n *\n * TAKE_FROM_BIGGEST = false: Return the *smallest* available bucket greater\n * than or equal to b.\n *\n * Returns -1 when no satisfactory bucket is available.\n */\n#define TAKE_FROM_BIGGEST true\n#if TAKE_FROM_BIGGEST\n#define GET_AVAILABLE_BUCKET(b, buckets) \\\n (-1 + (((AVAILABLE_NEXT_MASK(b, buckets)) \\\n & (PREV_BUCKETS_MASK((b) + 1 + BUCKET_DIVISION_THRESHOLD))) \\\n /* Smallest bucket >= b */ ? __builtin_ffs(AVAILABLE_NEXT_MASK(b, buckets)) \\\n /* Biggest bucket >= b */ : CEIL_LOG2(AVAILABLE_NEXT_MASK(b, buckets))))\n#else\n#define GET_AVAILABLE_BUCKET(b, buckets) __builtin_ffs(AVAILABLE_NEXT_MASK(b, buckets))\n#endif\n\n/*\n * Bit get/set/clear.\n */\n#define GET_BIT(x, bit) ((x) & (1 << (bit)))\n#define SET_BIT(x, bit) ((x) |= (1 << (bit)))\n#define CLEAR_BIT(x, bit) ((x) &= ~(1 << (bit)))\n\ntypedef struct __align__(512) {\n char data;\n} DataType;\n\n#define SIZE_ROUNDUP(size) (sizeof(DataType) * DIVUP((size), sizeof(DataType)))\n\nclass MemorySegment {\n friend class FastMemoryManager;\nprotected:\n DataType* _data;\n size_t _size;\n int _deviceID;\n // Resizes itself to _size - size and\n // returns pointer to new memory segment\n MemorySegment* subdivide(size_t size) {\n assert(size < _size);\n// assert(size % sizeof(DataType) == 0);\n _size -= size;\n return new MemorySegment(_data + _size / sizeof(DataType), size, _deviceID);\n }\n\n inline size_t getSize() const {\n return _size;\n }\npublic:\n MemorySegment(DataType* data, size_t size, int deviceID) : _data(data), _size(size), _deviceID(deviceID) {\n assert(size % sizeof(DataType) == 0);\n }\n // In some cases size is irrelevant\n template MemorySegment(T* data) : _data(reinterpret_cast(data)), _size(0), _deviceID(-1) {\n\n }\n\n template \n inline T* getData() const {\n return reinterpret_cast(_data);\n }\n\n template \n inline T** getDataPtr() {\n return reinterpret_cast(&_data);\n }\n\n inline int getDeviceID() const {\n return _deviceID;\n }\n};\n\nclass MemoryManager {\nprotected:\n static Lock _globalLock;\npublic:\n virtual MemoryManager* init() = 0;\n virtual MemorySegment* malloc(size_t size) = 0;\n virtual void free(MemorySegment* mem) = 0;\n virtual ~MemoryManager() {\n\n }\n};\n\nclass FastMemoryManager : public MemoryManager {\nprotected:\n int _deviceID;\n Lock _lock;\n DataType* _data;\n size_t _size;\n BUCKET_TYPE _buckets; // Bucket availability bit vector\n std::vector > _freeSegments; // bucket idx -> vector of segments\n\n static std::map _memoryManagers;\n\n virtual void allocateInitialSegment() {\n assert(_deviceID >= 0);\n assert(FIRST_BUCKET_SIZE % sizeof(DataType) == 0);\n checkCudaErrors(cudaSetDevice(_deviceID));\n size_t memFree, memTotal;\n checkCudaErrors(cudaMemGetInfo(&memFree, &memTotal));\n _size = sizeof(DataType) * (size_t(round(double(memFree) * GPU_ALLOC_FRACTION)) / sizeof(DataType));\n printf(\"FastMemoryManager[%d] allocating %lu-byte initial segment\\n\", _deviceID, _size);\n checkCudaErrors(cudaMalloc(&_data, _size));\n }\n\n virtual void freeInitialSegment() {\n checkCudaErrors(cudaFree(_data));\n }\n\npublic:\n static MemoryManager& getInstance(int deviceID);\n static void destroyInstance(int deviceID);\n\n FastMemoryManager(int deviceID) : _deviceID(deviceID), _data(NULL), _size(0), _buckets(0) {\n }\n\n ~FastMemoryManager() {\n freeInitialSegment();\n for (int i = 0; i < _freeSegments.size(); ++i) {\n for (int j = 0; j < _freeSegments[i].size(); ++j) {\n delete _freeSegments[i][j];\n }\n }\n }\n\n virtual MemoryManager* init() {\n allocateInitialSegment();\n\n for (int i = 0; i < NUM_BUCKETS; ++i) {\n _freeSegments.push_back(std::vector());\n }\n int bucket = GET_DEALLOC_BUCKET(_size);\n SET_BIT(_buckets, bucket);\n _freeSegments[bucket].push_back(new MemorySegment(_data, _size, _deviceID));\n return this;\n }\n\n MemorySegment* malloc(size_t size) {\n assert(size > 0);\n int requestedBucket = GET_ALLOC_BUCKET(size);\n _lock.acquire();\n\n int bucket = GET_AVAILABLE_BUCKET(requestedBucket, _buckets);\n// if (bucket - requestedBucket > BUCKET_DIVISION_THRESHOLD) {\n// printf(\"MemoryManager[%d] requested size: %lu, requested bucket: %d, available bucket: %d\\n\", _deviceID, size, requestedBucket, bucket);\n// }\n\n assert(bucket >= requestedBucket); // Out of memory\n\n MemorySegment* sourceSegment = _freeSegments[bucket].back();\n MemorySegment* ret = sourceSegment;\n if (bucket - requestedBucket > BUCKET_DIVISION_THRESHOLD) { // We got a much bigger chunk than we wanted\n ret = sourceSegment->subdivide(GET_BUCKET_SIZE(requestedBucket));\n int newSrcBucket = GET_DEALLOC_BUCKET(sourceSegment->getSize());\n if (newSrcBucket != bucket) {\n _freeSegments[bucket].pop_back();\n _freeSegments[newSrcBucket].push_back(sourceSegment);\n SET_BIT(_buckets, newSrcBucket);\n }\n } else {\n _freeSegments[bucket].pop_back();\n }\n if (_freeSegments[bucket].size() == 0) {\n CLEAR_BIT(_buckets, bucket);\n }\n _lock.release();\n return ret;\n }\n\n void free(MemorySegment* mem) {\n assert(mem != NULL);\n assert(mem->getSize() >= FIRST_BUCKET_SIZE);\n int bucket = GET_DEALLOC_BUCKET(mem->getSize());\n // Synchronize for safety, so that we don't free memory that's being used. Not synchronizing\n // could potentially cause a problem if we re-allocate the just-freed chunk and attempt to\n // use it in a different stream.\n if (SYNC_ON_FREE) {\n int d;\n checkCudaErrors(cudaGetDevice(&d));\n checkCudaErrors(cudaSetDevice(mem->getDeviceID()));\n checkCudaErrors(cudaDeviceSynchronize());\n checkCudaErrors(cudaSetDevice(d));\n }\n _lock.acquire();\n _freeSegments[bucket].push_back(mem);\n SET_BIT(_buckets, bucket);\n// printf(\"MemoryManager[%d] Freed segment of size %lu into bucket %lu\\n\", _deviceID, mem->getSize(), bucket);\n _lock.release();\n }\n};\n\nclass FastHostMemoryManager : public FastMemoryManager {\nprotected:\n static MemoryManager* _memoryManager;\n void allocateInitialSegment() {\n _size = HOST_ALLOC_CHUNK;\n checkCudaErrors(cudaHostAlloc(&_data, _size, cudaHostAllocPortable));\n }\n void freeInitialSegment () {\n checkCudaErrors(cudaFreeHost(_data));\n }\npublic:\n FastHostMemoryManager() : FastMemoryManager(DEVICE_HOST) {\n }\n\n static MemoryManager& getInstance();\n static void destroyInstance();\n};\n\nclass CUDAMemoryManager : public MemoryManager {\nprotected:\n static MemoryManager* _memoryManager;\n\n virtual void _malloc(DataType** data, size_t size) {\n checkCudaErrors(cudaMalloc(data, size));\n }\n virtual void _free(MemorySegment* mem) {\n checkCudaErrors(cudaFree(mem->getData()));\n }\npublic:\n static MemoryManager& getInstance(int deviceID);\n static void destroyInstance(int deviceID);\n CUDAMemoryManager() {\n }\n\n MemoryManager* init() {\n return this;\n }\n\n MemorySegment* malloc(size_t size) {\n MemorySegment* seg = new MemorySegment(reinterpret_cast(NULL));\n DataType** data = seg->getDataPtr();\n _malloc(data, size);\n return seg;\n }\n\n void free(MemorySegment* mem) {\n assert(mem != NULL);\n _free(mem);\n delete mem;\n }\n};\n\nclass CUDAHostMemoryManager : public CUDAMemoryManager {\nprotected:\n static MemoryManager* _memoryManager;\n void _free(MemorySegment* mem) {\n checkCudaErrors(cudaFreeHost(mem->getData()));\n }\n void _malloc(DataType** data, size_t size) {\n checkCudaErrors(cudaHostAlloc(data, size, cudaHostAllocPortable));\n }\npublic:\n static MemoryManager& getInstance();\n static void destroyInstance();\n CUDAHostMemoryManager() : CUDAMemoryManager() {\n\n }\n};\n#endif /* MEMORY_CUH_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/nvmatrix.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef NVMATRIX_H_\n#define NVMATRIX_H_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \"../../util/include/matrix.h\"\n#include \"nvmatrix_kernels.cuh\"\n#include \"nvmatrix_operators.cuh\"\n#include \"memory.cuh\"\n\n#ifdef WARNINGS\n#define WARN(msg) printf(\"WARN: File %s, line %d: %s\\n\", __FILE__, __LINE__, msg);\n#else\n#define WARN(msg) ;\n#endif\n\n#define CURAND_CALL(x) do { if((x) != CURAND_STATUS_SUCCESS) { \\\n printf(\"CURAND Error at %s:%d\\n\",__FILE__,__LINE__);\\\n exit(EXIT_FAILURE);}} while(0)\n\n#define CUBLAS_CALL(x) do { if((x) != CUBLAS_STATUS_SUCCESS) { \\\n printf(\"CUBLAS Error at %s:%d\\n\",__FILE__,__LINE__);\\\n exit(EXIT_FAILURE);}} while(0)\n\n/*\n * Memory manager to use for GPU memory allocations.\n *\n * CUDAMemoryManager: Default Nvidia memory manager; just calls cudaMalloc / cudaFree.\n * Allocating and freeing memory is slow.\n * FastMemoryManager: A GPU memory manager with very fast (constant time)\n * alloc / free, but possibly more wasteful of memory.\n */\n#define DEVICE_MEMORY_MANAGER CUDAMemoryManager\n\n/*\n * Memory manager to use for host memory allocations.\n *\n * CUDAHostMemoryManager: Default Nvidia memory manager; just calls cudaHostAlloc / cudaFreeHost.\n * Allocating and freeing memory is slow.\n * FastHostMemoryManager: A host memory manager with very fast (constant time)\n * alloc / free, but possibly more wasteful of memory.\n */\n#define HOST_MEMORY_MANAGER CUDAHostMemoryManager\n\nclass NVMatrix;\ntypedef std::vector NVMatrixV;\n\nclass NVMatrix {\nprotected:\n int _numCols, _numRows;\n int _numElements;\n int _stride;\n// float* getDevData();\n MemorySegment* _memSegment;\n bool _isTrans;\n bool _ownsData;\n // This flag makes sure that the NVMatrix destructor does nothing\n // when called on HostNVMatrix instance.\n bool _deleted;\n cudaTextureObject_t _texObj;\n\n// static std::map rndGen;\n static std::map _rndDevStates;\n static std::map _cublasHandles;\n // Map from device id --> # of random streams initialized on that device\n static std::map _rndDevThreads;\n static pthread_mutex_t *_rndMutex, *_cublasMutex, *_streamMutex;\n // Map from device id --> default stream\n static std::map _defaultStreams;\n\n cublasOperation_t getTransChar() const {\n /*\n * not a typo! return opposite character because a\n * non-transposed nvmatrix is in row-major order while a non-transposed\n * cublas matrix is in column-major order.\n */\n return _isTrans ? CUBLAS_OP_N : CUBLAS_OP_T;\n }\n\n void _init(bool isTrans);\n void _sum_setParams(int n, dim3* blocks, dim3* threads);\n template float cpuAgg(Agg agg, cudaStream_t stream);\n template float _totalAgg(Agg agg);\n template float _totalAgg(Agg agg, cudaStream_t stream);\n template float _totalAgg(Agg agg, NVMatrix& tmpbuf, cudaStream_t stream);\n template void _aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop, cudaStream_t stream, NVMatrix* tmp);\n template void _aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop, cudaStream_t stream);\n template void _aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop);\n template void _aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop, cudaStream_t stream);\n template void _aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop);\n template NVMatrix& _aggregate(int axis, Agg agg, BinaryOp bop, cudaStream_t stream);\n template NVMatrix& _aggregate(int axis, Agg agg, BinaryOp bop);\n template NVMatrix& _aggregate(int axis, Agg agg, UnaryOp, BinaryOp bop, cudaStream_t stream);\n template NVMatrix& _aggregate(int axis, Agg agg, UnaryOp, BinaryOp bop);\n\n template void _aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop, NVMatrix& tmp);\n template void _aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop, cudaStream_t stream, NVMatrix& tmp);\n template void _aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop, NVMatrix& tmp);\n template NVMatrix& _aggregate(int axis, Agg agg, BinaryOp bop, cudaStream_t stream, NVMatrix& tmp);\n template NVMatrix& _aggregate(int axis, Agg agg, BinaryOp bop, NVMatrix& tmp);\n template NVMatrix& _aggregate(int axis, Agg agg, UnaryOp, BinaryOp bop, cudaStream_t stream, NVMatrix& tmp);\n template NVMatrix& _aggregate(int axis, Agg agg, UnaryOp, BinaryOp bop, NVMatrix& tmp);\n\n template void _unaryRandomize(NVMatrix& target, Randomizer rnd, cudaStream_t stream);\n template void _unaryRandomize(NVMatrix& target, Randomizer rnd);\n template void _binaryRandomize(NVMatrix& data2, NVMatrix& target, Randomizer rnd);\n template void _binaryRandomize(NVMatrix& data2, NVMatrix& target, Randomizer rnd, cudaStream_t stream);\n\n virtual void alloc(int numElements);\n virtual void dealloc();\n void deallocTexture();\n virtual NVMatrix& construct() const;\n virtual NVMatrix& construct(bool isTrans) const;\n virtual NVMatrix& construct(int numRows, int numCols, bool isTrans=false) const;\n virtual NVMatrix& construct(const Matrix& like, bool copy) const;\n virtual NVMatrix& construct(const NVMatrix& like, bool copy) const;\n virtual NVMatrix& construct(const NVMatrix& like) const;\n virtual NVMatrix& construct(const Matrix& like) const;\n virtual NVMatrix& construct(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans) const;\n static cublasHandle_t getCublasHandle();\n static cublasHandle_t getCublasHandle(int deviceID);\npublic:\n NVMatrix();\n NVMatrix(bool isTrans);\n NVMatrix(int numRows, int numCols, bool isTrans=false);\n NVMatrix(const Matrix& like, bool copy);\n NVMatrix(const NVMatrix& like, bool copy);\n NVMatrix(const NVMatrix& like);\n NVMatrix(const Matrix& like);\n NVMatrix(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans);\n virtual ~NVMatrix();\n\n // Returns the device ID on which the data pointer is allocated\n int getDataDeviceID() const;\n static void initRandom(unsigned long long seed, int numStreams, cudaStream_t stream);\n static void initRandom(unsigned long long seed, int numStreams);\n static void initRandom(unsigned long long seed);\n static void initRandom();\n static void initCublas();\n static void destroyCublas();\n static std::pair getCudaMemorySize();\n\n // Returns the currently-active device ID for calling thread\n static int getDeviceID();\n static void setDeviceID(int d);\n static bool canAccessPeer(int srcDevice, int tgtDevice);\n static bool isRndInitialized();\n static bool isRndInitialized(bool haveLock);\n static curandState* getCurandState();\n static curandState* getCurandState(int numStreams);\n static void destroyRandom();\n static pthread_mutex_t* makeMutex();\n static cudaStream_t getDefaultStream(int deviceID);\n static cudaStream_t getDefaultStream();\n static void syncDevice();\n static void syncStream();\n static void syncStream(cudaStream_t stream);\n\n /*\n * DO NOT DEREFERENCE IN HOST CODE! This is a device memory pointer.\n */\n float* getCellPtr(int i, int j) const {\n if (_isTrans) {\n return &getDevData()[j * _numRows + i];\n }\n return &getDevData()[i * _numCols + j];\n }\n\n bool isSameDims(const Matrix& m) const {\n return m.getNumRows() == _numRows && m.getNumCols() == _numCols;\n }\n\n bool isSameDims(const NVMatrix& m) const {\n return m.getNumRows() == _numRows && m.getNumCols() == _numCols;\n }\n\n int getNumRows() const {\n return _numRows;\n }\n\n int getNumCols() const {\n return _numCols;\n }\n\n int getStride() const {\n return _stride;\n }\n\n int getLeadingDim() const {\n return _isTrans ? _numRows : _numCols;\n }\n\n int getFollowingDim() const {\n return !_isTrans ? _numRows : _numCols;\n }\n\n /*\n * FALSE: Row-major order.\n * TRUE: Column-major order.\n */\n bool isTrans() const {\n return _isTrans;\n }\n\n bool isView() const {\n return !_ownsData;\n }\n\n float* getDevData() const {\n return _memSegment == NULL ? NULL : _memSegment->getData();\n }\n\n MemorySegment& getMemorySegment() const {\n return *_memSegment;\n }\n\n int getNumElements() const {\n return _numElements;\n }\n\n size_t getNumDataBytes() const {\n return size_t(_numElements) * 4;\n }\n\n /*\n * Only use if you know what you're doing!\n * Does not actually transpose matrix.\n */\n void setTrans(bool trans) {\n if (trans != _isTrans) {\n assert(isContiguous());\n _isTrans = trans;\n _stride = getLeadingDim();\n }\n }\n\n /*\n * Only use if you know what you're doing!\n * This toggles whether this object will free its GPU memory when it's destroyed.\n */\n void setIsView(bool isView) {\n _ownsData = !isView;\n }\n\n bool isContiguous() const {\n return _stride == getLeadingDim() || getFollowingDim() == 1;\n }\n\n void truncate() {\n resize(0,0);\n }\n\n virtual cudaTextureObject_t getTextureObject();\n\n virtual void copyFromHost(const Matrix& hostMatrix);\n virtual void copyFromHost(const Matrix& hostMatrix, bool resizeTarget);\n virtual void copyFromHost(const Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream);\n virtual void copyToHost(Matrix& hostMatrix) const;\n virtual void copyToHost(Matrix& hostMatrix, bool resizeTarget) const;\n virtual void copyToHost(Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream) const;\n void copy(NVMatrix& dest) const;\n void copy(NVMatrix& dest, cudaStream_t stream) const;\n NVMatrix& copy() const;\n void addProduct(NVMatrix& a, NVMatrix &b, float scaleThis, float scaleAB, cudaStream_t stream);\n void addProduct(NVMatrix& a, NVMatrix &b, float scaleThis, float scaleAB);\n void addProduct(NVMatrix& a, NVMatrix &b);\n void rightMult(NVMatrix &b, float scaleAB, NVMatrix &target, cudaStream_t stream);\n void rightMult(NVMatrix &b, float scaleAB, NVMatrix &target);\n void rightMult(NVMatrix &b, NVMatrix &target);\n void rightMult(NVMatrix &b, float scaleAB);\n void randomizeUniform();\n void addGaussianNoise(NVMatrix& stdevs, bool var, NVMatrix& target);\n void addGaussianNoise(float stdev, NVMatrix& target);\n void addGaussianNoise(NVMatrix& stdevs, bool var);\n void addGaussianNoise(NVMatrix& stdevs);\n void addGaussianNoise(float stdev);\n void addGaussianNoise();\n void randomizeGaussian();\n void randomizeGaussian(float stdev);\n void randomizeGaussian(float mean, float stdev);\n void randomizeGaussian(float mean, NVMatrix& stdevs);\n void randomizeGaussian(float mean, float stdevMult, NVMatrix& stdevs);\n void randomizeGaussian(NVMatrix& stdevs);\n void randomizeGaussian(NVMatrix& stdevs, NVMatrix& target);\n void binarizeProbs();\n void binarizeProbs(NVMatrix& target);\n\n void biggerThan(NVMatrix& m, NVMatrix& target);\n void biggerThan(NVMatrix& m);\n void biggerThanVector(NVMatrix& vec, NVMatrix& target);\n void biggerThanVector(NVMatrix& vec);\n void equals(NVMatrix& m, NVMatrix& target);\n void equals(NVMatrix& m);\n\n void _checkBounds(int startRow, int endRow, int startCol, int endCol) const;\n NVMatrix& slice(int startRow, int endRow, int startCol, int endCol) const;\n void slice(int startRow, int endRow, int startCol, int endCol, NVMatrix& target) const;\n NVMatrix& sliceRows(int startRow, int endRow) const;\n void sliceRows(int startRow, int endRow, NVMatrix& target) const;\n NVMatrix& sliceCols(int startCol, int endCol) const;\n void sliceCols(int startCol, int endCol, NVMatrix& target) const;\n\n NVMatrixV& splitRows(int numParts);\n NVMatrixV& splitCols(int numParts);\n\n template void apply(Op op, NVMatrix& target, cudaStream_t stream) {\n if (!target.isSameDims(*this)) {\n target.resize(*this);\n }\n if (getNumElements() > 0) {\n int height = target.getFollowingDim(), width = target.getLeadingDim();\n\n if (target.isTrans() == isTrans()) {\n if (!isContiguous() || !target.isContiguous()) {\n dim3 blocks(std::min(NUM_BLOCKS_MAX, DIVUP(width, ELTWISE_THREADS_X)),\n std::min(NUM_BLOCKS_MAX, DIVUP(height, ELTWISE_THREADS_Y)));\n dim3 threads(ELTWISE_THREADS_X, ELTWISE_THREADS_Y);\n kEltwiseUnaryOp<<>>(getDevData(), target.getDevData(), height, width, getStride(), target.getStride(), op);\n getLastCudaError(\"kEltwiseUnaryOp: Kernel execution failed\");\n } else {\n dim3 threads = dim3(ELTWISE_FLAT_THREADS_X);\n dim3 blocks = dim3(std::min(128, DIVUP(_numElements, ELTWISE_FLAT_THREADS_X)));\n kEltwiseUnaryOpFlat<<>>(getDevData(), target.getDevData(), _numElements, op);\n getLastCudaError(\"kEltwiseUnaryOpFlat: Kernel execution failed\");\n }\n } else {\n dim3 blocks(std::min(NUM_BLOCKS_MAX, DIVUP(width, ELTWISE_THREADS_X)),\n std::min(NUM_BLOCKS_MAX, DIVUP(height, ELTWISE_THREADS_Y)));\n dim3 threads(ELTWISE_THREADS_X, ELTWISE_THREADS_Y);\n bool checkBounds = !(width % ELTWISE_THREADS_X == 0 && height % ELTWISE_THREADS_X == 0);\n // printf(\"height: %d, width: %d, stride: %d, target stride: %d, check bounds: %d, threads.x: %d, threads.y: %d, blocks.x: %d, blocks.y: %d\\n\",\n // height, width, getStride(), target.getStride(), checkBounds, threads.x, threads.y, blocks.x, blocks.y);\n if (checkBounds) {\n kEltwiseUnaryOpTrans<<>>(getDevData(), target.getDevData(), height, width, getStride(), target.getStride(), op);\n } else {\n kEltwiseUnaryOpTrans<<>>(getDevData(), target.getDevData(), height, width, getStride(), target.getStride(), op);\n }\n getLastCudaError(\"kEltwiseUnaryOpTrans: Kernel execution failed\");\n }\n }\n }\n\n template void apply(Op op, cudaStream_t stream) {\n apply(op, *this, stream);\n }\n\n template void apply(Op op, NVMatrix& target) {\n apply(op, target, getDefaultStream());\n }\n\n template void apply(Op op) {\n apply(op, *this);\n }\n\n template void applyBinary(Op op, NVMatrix& b) {\n applyBinary(op, b, *this);\n }\n\n template void applyBinary(Op op, NVMatrix& b, NVMatrix& target) {\n applyBinary(op, b, target, getDefaultStream());\n }\n\n template void applyBinary(Op op, NVMatrix& b, NVMatrix& target, cudaStream_t stream) {\n assert(this->isSameDims(b));\n\n if (!target.isSameDims(*this)) {\n target.resize(*this);\n }\n\n if (getNumElements() > 0) {\n int height = target.getFollowingDim(), width = target.getLeadingDim();\n if (target.isTrans() == isTrans() && target.isTrans() == b.isTrans()) {\n if (!isContiguous() || !b.isContiguous() || !target.isContiguous()) {\n dim3 blocks(std::min(128, DIVUP(width, ELTWISE_THREADS_X)),\n std::min(128, DIVUP(height, ELTWISE_THREADS_Y)));\n dim3 threads(ELTWISE_THREADS_X, ELTWISE_THREADS_Y);\n kEltwiseBinaryOp<<>>(getDevData(), b.getDevData(), target.getDevData(), height, width, getStride(),\n b.getStride(), target.getStride(), op);\n } else {\n dim3 threads = dim3(ELTWISE_FLAT_THREADS_X);\n dim3 blocks = dim3(std::min(128, DIVUP(_numElements, ELTWISE_FLAT_THREADS_X)));\n kEltwiseBinaryOpFlat<<>>(getDevData(), b.getDevData(), target.getDevData(), _numElements, op);\n }\n getLastCudaError(\"kEltwiseBinaryOp: Kernel execution failed\");\n } else {\n\n dim3 blocks(std::min(128, DIVUP(width, ELTWISE_THREADS_X)),\n std::min(128, DIVUP(height, ELTWISE_THREADS_Y)));\n dim3 threads(ELTWISE_THREADS_X, ELTWISE_THREADS_Y);\n // both x here since y divides x\n bool checkBounds = !(width % ELTWISE_THREADS_X == 0 && height % ELTWISE_THREADS_X == 0);\n if (target.isTrans() == isTrans() && target.isTrans() != b.isTrans()) {\n if (checkBounds) {\n kEltwiseBinaryOpTrans<<>>(getDevData(), b.getDevData(), target.getDevData(), height, width,getStride(),\n b.getStride(), target.getStride(), op);\n } else {\n kEltwiseBinaryOpTrans<<>>(getDevData(), b.getDevData(), target.getDevData(), height, width,getStride(),\n b.getStride(), target.getStride(), op);\n }\n } else if (target.isTrans() != isTrans() && target.isTrans() != b.isTrans()) {\n if (checkBounds) {\n kEltwiseBinaryOpTrans<<>>(getDevData(), b.getDevData(), target.getDevData(), height, width,getStride(),\n b.getStride(), target.getStride(), op);\n } else {\n kEltwiseBinaryOpTrans<<>>(getDevData(), b.getDevData(), target.getDevData(), height, width,getStride(),\n b.getStride(), target.getStride(), op);\n }\n } else if (target.isTrans() != isTrans() && target.isTrans() == b.isTrans()) {\n if (checkBounds) {\n kEltwiseBinaryOpTrans<<>>(b.getDevData(), getDevData(), target.getDevData(), height, width,b.getStride(),\n getStride(), target.getStride(), op);\n } else {\n kEltwiseBinaryOpTrans<<>>(b.getDevData(), getDevData(), target.getDevData(), height, width, b.getStride(),\n getStride(), target.getStride(), op);\n }\n }\n getLastCudaError(\"kEltwiseBinaryOpTrans: Kernel execution failed\");\n }\n }\n }\n\n template void applyTernary(Op op, NVMatrix& b, NVMatrix& c, NVMatrix& target) {\n applyTernary(op, b, c, target, getDefaultStream());\n }\n\n template void applyTernary(Op op, NVMatrix& b, NVMatrix& c, NVMatrix& target, cudaStream_t stream) {\n assert(isSameDims(b));\n assert(isSameDims(c));\n // For now ternary ops are only supported for matrices of same transposedness\n assert(isTrans() == b.isTrans());\n assert(isTrans() == c.isTrans());\n if (!target.isSameDims(*this) || target.isTrans() != isTrans()) {\n target.resize(*this);\n }\n if (getNumElements() > 0) {\n int height = target.getFollowingDim(), width = target.getLeadingDim();\n if (!isContiguous() || !b.isContiguous() || !c.isContiguous() || !target.isContiguous()) {\n dim3 blocks(std::min(512, DIVUP(width, ELTWISE_THREADS_X)),\n std::min(512, DIVUP(height, ELTWISE_THREADS_Y)));\n dim3 threads(ELTWISE_THREADS_X, ELTWISE_THREADS_Y);\n kEltwiseTernaryOp<<>>(getDevData(), b.getDevData(), c.getDevData(), target.getDevData(), height, width,\n getStride(), b.getStride(), c.getStride(), target.getStride(), op);\n getLastCudaError(\"kEltwiseTernaryOp: Kernel execution failed\");\n } else {\n dim3 threads = dim3(ELTWISE_FLAT_THREADS_X);\n dim3 blocks = dim3(std::min(128, DIVUP(_numElements, ELTWISE_FLAT_THREADS_X)));\n kEltwiseTernaryOpFlat<<>>(getDevData(), b.getDevData(), c.getDevData(), target.getDevData(), _numElements, op);\n getLastCudaError(\"kEltwiseTernaryOpFlat: Kernel execution failed\");\n }\n }\n }\n\n bool resize(int numRows, int numCols, bool trans);\n bool resize(int numRows, int numCols);\n bool resize(const NVMatrix &like);\n bool resize(const Matrix &like);\n void reshape(int numRows, int numCols);\n NVMatrix& reshaped(int numRows, int numCols) const;\n void copy(NVMatrix &dest, int srcStartRow, int srcEndRow, int srcStartCol, int srcEndCol, int destStartRow, int destStartCol) const;\n void copy(NVMatrix &dest, int srcStartRow, int srcEndRow, int srcStartCol, int srcEndCol, int destStartRow, int destStartCol, cudaStream_t stream) const;\n void add(NVMatrix& b, float scaleA, float scaleB, NVMatrix& target, cudaStream_t stream);\n void add(NVMatrix& b, float scaleA, float scaleB, NVMatrix& target);\n void add(NVMatrix& b, float scaleB, NVMatrix& target);\n void add(NVMatrix& b, NVMatrix& target);\n void add(NVMatrix& b, float scaleB);\n void add(NVMatrix& b, float scaleA, float scaleB);\n void add(NVMatrix& b);\n void eltwiseMult(NVMatrix& b);\n void eltwiseMult(NVMatrix& b, NVMatrix& target);\n void eltwiseDivide(NVMatrix& b);\n void eltwiseDivide(NVMatrix& b, NVMatrix& target);\n void squaredDiff(NVMatrix& b);\n void squaredDiff(NVMatrix& b, NVMatrix& target);\n void subtract(NVMatrix& b, NVMatrix& target);\n void subtract(NVMatrix& b);\n void addVector(NVMatrix& vec, float scaleVec, NVMatrix& target, cudaStream_t stream);\n void addVector(NVMatrix& vec, float scaleVec, NVMatrix& target);\n void addVector(NVMatrix& vec);\n void addVector(NVMatrix& vec, float scaleVec);\n void addVector(NVMatrix& vec, NVMatrix& target);\n void equalsVector(NVMatrix& vec, NVMatrix& target);\n void equalsVector(NVMatrix& vec);\n void eltwiseMultByVector(NVMatrix& vec, NVMatrix& target, cudaStream_t stream);\n void eltwiseMultByVector(NVMatrix& vec, NVMatrix& target);\n void eltwiseMultByVector(NVMatrix& vec);\n void eltwiseMultByVector(NVMatrix& vec, cudaStream_t stream);\n void eltwiseDivideByVector(NVMatrix& vec, NVMatrix& target);\n void eltwiseDivideByVector(NVMatrix& vec);\n void tile(int timesY, int timesX, NVMatrix& target);\n void tile(int timesY, int timesX, NVMatrix& target, cudaStream_t stream);\n\n void addSum(NVMatrix& a, int axis, float scaleThis, float scaleSum);\n void addSum(NVMatrix& a, int axis, float scaleThis, float scaleSum, cudaStream_t stream);\n void addMax(NVMatrix& a, int axis, float scaleThis, float scaleMax);\n void addMax(NVMatrix& a, int axis, float scaleThis, float scaleMax, cudaStream_t stream);\n void sum(int axis, NVMatrix& target, cudaStream_t stream);\n void sum(int axis, NVMatrix& target);\n void sum(int axis, NVMatrix& target, cudaStream_t stream, NVMatrix& tmp);\n void sum(int axis, NVMatrix& target, NVMatrix& tmp);\n NVMatrix& sum(int axis);\n void max(int axis, NVMatrix& target);\n void max(int axis, NVMatrix& target, NVMatrix& tmp);\n NVMatrix& max(int axis);\n void min(int axis, NVMatrix& target);\n NVMatrix& min(int axis);\n void sumOfSquares(int axis, NVMatrix& target, cudaStream_t stream);\n void sumOfSquares(int axis, NVMatrix& target);\n NVMatrix& sumOfSquares(int axis);\n float mean();\n float sum();\n float sum(NVMatrix& tmpbuf);\n float max();\n float min();\n float countInf();\n float countNan();\n float norm2();\n float norm();\n\n void inRangeInc(float lower, float upper);\n void inRangeInc(float lower, float upper, NVMatrix& target);\n void inRangeExc(float lower, float upper);\n void inRangeExc(float lower, float upper, NVMatrix& target);\n void biggerThanScalar(float scalar);\n void biggerThanScalar(float scalar, NVMatrix& target);\n void smallerThanScalar(float scalar);\n void smallerThanScalar(float scalar, NVMatrix& target);\n void addScalar(float scaleThis, float scalar, NVMatrix& target);\n void addScalar(float scalar, NVMatrix& target);\n void addScalar(float scalar);\n void minWithScalar(float scalar, NVMatrix& target);\n void minWithScalar(float scalar);\n void maxWithScalar(float scalar, NVMatrix& target);\n void maxWithScalar(float scalar);\n void pow(float p, NVMatrix& target);\n void pow(float p);\n void scale(float _scale);\n void scale(float _scale, NVMatrix& target);\n void scale(float _scale, NVMatrix& target, cudaStream_t stream);\n void scale(float _scale, cudaStream_t stream);\n void zero();\n void zero(NVMatrix& like);\n\n float dotProduct(NVMatrix& b, NVMatrix& tmp, cudaStream_t stream);\n float dotProduct(NVMatrix& b, cudaStream_t stream);\n float dotProduct(NVMatrix& b);\n\n /*\n * Does SOFT transpose and returns result, leaving this matrix unchanged\n */\n NVMatrix& getTranspose();\n NVMatrix& getClone();\n\n /*\n * Does HARD transpose and puts result in target\n */\n void transpose(NVMatrix& target);\n\n /*\n * Does SOFT transpose\n */\n void transpose();\n bool transpose(bool trans);\n\n void flipTrans(NVMatrix& target, cudaStream_t stream);\n void flipTrans(NVMatrix& target);\n NVMatrix& flipTrans();\n\n void print(int startRow, int rows, int startCol, int cols) const;\n void print(int rows, int cols) const;\n void printShape(const char* name) const;\n\n template void applyBinaryV(Op op, NVMatrix& vec, NVMatrix& target) {\n applyBinaryV(op, vec, target, getDefaultStream());\n }\n\n template void applyBinaryV(Op op, NVMatrix& vec, NVMatrix& target, cudaStream_t stream) {\n assert(&target != &vec); // for now\n if (isSameDims(vec)) {\n applyBinary(op, vec, target, stream);\n return;\n }\n assert(vec.getNumRows() == 1 || vec.getNumCols() == 1);\n assert(vec.getNumRows() == _numRows || vec.getNumCols() == _numCols);\n assert(vec.isContiguous());\n\n target.resize(*this); // target must be same orientation as me for now\n int width = getLeadingDim(); //_isTrans ? _numRows : _numCols;\n int height = getFollowingDim(); //_isTrans ? _numCols : _numRows;\n dim3 threads(ADD_VEC_THREADS_X, ADD_VEC_THREADS_Y);\n\n if ((vec.getNumRows() == _numRows && !isTrans()) || (vec.getNumCols() == _numCols && isTrans())) {\n dim3 blocks(std::min(512, DIVUP(width, ADD_VEC_THREADS_X)), std::min(NUM_BLOCKS_MAX, DIVUP(height, ADD_VEC_THREADS_Y)));\n kColVectorOp<<>>(getDevData(), vec.getDevData(), target.getDevData(), width, height, getStride(), target.getStride(), op);\n } else {\n dim3 blocks(std::min(NUM_BLOCKS_MAX, DIVUP(width, ADD_VEC_THREADS_X)), std::min(NUM_BLOCKS_MAX, DIVUP(height, ADD_VEC_THREADS_Y)));\n kRowVectorOp<<>>(getDevData(), vec.getDevData(), target.getDevData(), width, height, getStride(), target.getStride(), op);\n }\n getLastCudaError(\"Kernel execution failed\");\n // cudaThreadSynchronize();\n }\n\n template float argMax(UnaryOperator u) {\n return _totalAgg(NVMatrixAggs::ArgMax(u));\n }\n static void batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB, cudaStream_t stream, const float** aPtrsDev, const float** bPtrsDev, float** tgtPtrsDev);\n static void batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB, cudaStream_t stream);\n static void batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB, const float** aPtrsDev, const float** bPtrsDev, float** tgtPtrsDev);\n static void batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB);\n\n static void assertSame(NVMatrixV& a);\n};\n\nclass HostNVMatrix : public NVMatrix {\nprotected:\n void alloc(int numElements);\n void dealloc();\n NVMatrix& construct() const;\n NVMatrix& construct(bool isTrans) const;\n NVMatrix& construct(int numRows, int numCols, bool isTrans=false) const;\n NVMatrix& construct(const Matrix& like, bool copy) const;\n NVMatrix& construct(const NVMatrix& like, bool copy) const;\n NVMatrix& construct(const NVMatrix& like) const;\n NVMatrix& construct(const Matrix& like) const;\n NVMatrix& construct(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans) const;\npublic:\n ~HostNVMatrix();\n HostNVMatrix();\n HostNVMatrix(bool isTrans);\n HostNVMatrix(int numRows, int numCols, bool isTrans=false);\n HostNVMatrix(const Matrix& like, bool copy);\n HostNVMatrix(const NVMatrix& like, bool copy);\n HostNVMatrix(const NVMatrix& like);\n HostNVMatrix(const Matrix& like);\n HostNVMatrix(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans);\n void copyFromHost(const Matrix& hostMatrix);\n void copyFromHost(const Matrix& hostMatrix, bool resizeTarget);\n void copyFromHost(const Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream);\n void copyToHost(Matrix& hostMatrix) const;\n void copyToHost(Matrix& hostMatrix, bool resizeTarget) const;\n void copyToHost(Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream) const;\n cudaTextureObject_t getTextureObject();\n};\n\n#endif /* NVMATRIX_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/nvmatrix_kernels.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef NVMATRIX_KERNEL_H_\n#define NVMATRIX_KERNEL_H_\n\n#include \n\n#if defined(_WIN64) || defined(_WIN32)\n#define uint unsigned int\n#endif\n\n#define NUM_BLOCKS_MAX 65535\n#define TEXTURE_SIZE_MAX (1<<29)\n\n#define NUM_RND_BLOCKS 96\n#define NUM_RND_THREADS_PER_BLOCK 128\n#define NUM_RND_STREAMS (NUM_RND_BLOCKS * NUM_RND_THREADS_PER_BLOCK)\n\n/*\n * Default grid/block sizes for the various functions.\n */\n#define ADD_BLOCK_SIZE 16\n\n#define NUM_TILE_BLOCKS 4096\n#define NUM_TILE_THREADS_PER_BLOCK 512\n\n#define ELTWISE_THREADS_X 32\n#define ELTWISE_THREADS_Y 8\n\n#define ELTWISE_FLAT_THREADS_X 128\n\n#define NUM_SUM_COLS_THREADS_PER_BLOCK 128\n\n#define AGG_SHORT_ROWS_THREADS_X 32\n#define AGG_SHORT_ROWS_THREADS_Y 8\n#define AGG_SHORT_ROWS_LOOPS_Y 32\n\n#define DP_BLOCKSIZE 512\n#define CPUSUM_MAX 4096\n\n#define ADD_VEC_THREADS_X 64\n#define ADD_VEC_THREADS_Y 4\n\n#ifndef DIVUP\n#define DIVUP(x, y) (((x) + (y) - 1) / (y))\n#endif\n\n#define MYMAX(a, b) ((a) > (b) ? (a) : (b))\n\n#ifndef MUL24 // legacy\n#define MUL24(x,y) ((x) * (y))\n#endif\n\n#define AWR_NUM_THREADS 256\n#define WARP_SIZE 32\n#define AWR_NUM_WARPS AWR_NUM_THREADS / WARP_SIZE \n#define AWR_LOG_NUM_THREADS 8\n#define LOG_WARP_SIZE 5\n#define AWR_LOG_NUM_WARPS 3\n\n#define DEVICE_HOST -1\n#define DEVICE_NULL -2\n\n__global__ void kTile(const float* src, float* tgt, const uint srcWidth, const uint srcHeight, const uint tgtWidth, const uint tgtHeight);\n__global__ void kDotProduct_r(float* a, float* b, float* target, const uint numElements);\n__global__ void kSetupCurand(curandState *state, unsigned long long seed);\n\ntemplate \n__device__ T shfl_down(T a, int b, int c=WARP_SIZE) {\n#if __CUDA_ARCH__ >= 300\n return __shfl_down(a, b, c);\n#else\n return 0;\n#endif\n}\n\n/*\n * For now this is supported only for arrays with the same transposedness.\n */\ntemplate\n__global__ void kEltwiseTernaryOp(const float* a, const float* b, const float* c, float* const dest,\n const uint height, const uint width, uint strideA, const uint strideB, const uint strideC,\n const uint strideDest, Op op) {\n const uint idxX = blockIdx.x * ELTWISE_THREADS_X + threadIdx.x;\n const uint idxY = blockIdx.y * ELTWISE_THREADS_Y + threadIdx.y;\n\n for (uint y = idxY; y < height; y += gridDim.y * ELTWISE_THREADS_Y) {\n for (uint x = idxX; x < width; x += gridDim.x * ELTWISE_THREADS_X) {\n dest[y * strideDest + x] = op(a[y * strideA + x], b[y * strideB + x], c[y * strideC + x]);\n }\n }\n}\n\ntemplate\n__global__ void kEltwiseTernaryOpFlat(const float* a, const float* b, const float* c, float* const dest, const uint numElements, Op op) {\n const uint idxX = blockIdx.x * ELTWISE_FLAT_THREADS_X + threadIdx.x;\n\n for (uint x = idxX; x < numElements; x += gridDim.x * ELTWISE_FLAT_THREADS_X) {\n dest[x] = op(a[x], b[x], c[x]);\n }\n}\n\n\n/*\n * dest here is assumed to be \"not transposed\" -- height and width correspond to it.\n * b is assumed to be transposed.\n * a can be either transposed or not -- depending on parameter.\n * \n * Performs dest := op(a, b)\n */\ntemplate\n__global__ void kEltwiseBinaryOpTrans(const float* a, const float* b, float* const dest,\n const uint height, const uint width,\n const uint strideA, const uint strideB, const uint strideDest, Op op) {\n\n __shared__ float shmem[ELTWISE_THREADS_X][ELTWISE_THREADS_X + 1];\n\n // x here because that's how much work we do\n for (uint by = ELTWISE_THREADS_X * blockIdx.y; by < height; by += ELTWISE_THREADS_X * gridDim.y) {\n for (uint bx = ELTWISE_THREADS_X * blockIdx.x; bx < width; bx += ELTWISE_THREADS_X * gridDim.x) {\n const uint readX = by + threadIdx.x;\n const uint readY = bx + threadIdx.y;\n\n for (uint y = 0; y < ELTWISE_THREADS_X; y+= ELTWISE_THREADS_Y) {\n if (!checkBounds || (readX < height && readY + y < width)) {\n if (aTrans) {\n shmem[threadIdx.x][threadIdx.y + y] = reverse ? op(b[(readY+y) * strideB + readX], a[(readY+y) * strideA + readX])\n : op(a[(readY+y) * strideA + readX], b[(readY+y) * strideB + readX]);\n } else {\n shmem[threadIdx.x][threadIdx.y + y] = b[(readY+y) * strideB + readX];\n }\n }\n }\n __syncthreads();\n\n const uint writeX = bx + threadIdx.x;\n const uint writeY = by + threadIdx.y;\n\n for (uint y = 0; y < ELTWISE_THREADS_X; y+= ELTWISE_THREADS_Y) {\n if(!checkBounds || (writeX < width && writeY + y < height)) {\n if (aTrans) {\n dest[(writeY + y) * strideDest + writeX] = shmem[threadIdx.y + y][threadIdx.x];\n } else {\n dest[(writeY + y) * strideDest + writeX] = reverse ? op(shmem[threadIdx.y + y][threadIdx.x], a[(writeY + y) * strideA + writeX])\n : op(a[(writeY + y) * strideA + writeX], shmem[threadIdx.y + y][threadIdx.x]);\n }\n }\n }\n __syncthreads();\n }\n }\n}\ntemplate\n__global__ void kEltwiseBinaryOp(const float* a, const float* b, float* const dest, const uint height, const uint width,\n const uint strideA, const uint strideB, const uint strideDest, Op op) {\n const uint idxX = blockIdx.x * ELTWISE_THREADS_X + threadIdx.x;\n const uint idxY = blockIdx.y * ELTWISE_THREADS_Y + threadIdx.y;\n\n for (uint y = idxY; y < height; y += gridDim.y * ELTWISE_THREADS_Y) {\n for (uint x = idxX; x < width; x += gridDim.x * ELTWISE_THREADS_X) {\n dest[y * strideDest + x] = op(a[y * strideA + x], b[y * strideB + x]);\n }\n }\n}\n\ntemplate\n__global__ void kEltwiseBinaryOpFlat(const float* a, const float* b, float* const dest, const uint numElements, Op op) {\n const uint idxX = blockIdx.x * ELTWISE_FLAT_THREADS_X + threadIdx.x;\n\n for (uint x = idxX; x < numElements; x += gridDim.x * ELTWISE_FLAT_THREADS_X) {\n dest[x] = op(a[x], b[x]);\n }\n}\n\n/*\n * dest here is assumed to be \"not transposed\" -- height and width correspond to it.\n */\ntemplate\n__global__ void kEltwiseUnaryOpTrans(const float* a, float* const dest,\n const uint height, const uint width,\n const uint strideA, const uint strideDest, Op op) {\n\n __shared__ float shmem[ELTWISE_THREADS_X][ELTWISE_THREADS_X + 1];\n\n for (uint by = ELTWISE_THREADS_X * blockIdx.y; by < height; by += ELTWISE_THREADS_X * gridDim.y) {\n for (uint bx = ELTWISE_THREADS_X * blockIdx.x; bx < width; bx += ELTWISE_THREADS_X * gridDim.x) {\n const uint readX = by + threadIdx.x;\n const uint readY = bx + threadIdx.y;\n for (uint y = 0; y < ELTWISE_THREADS_X; y+= ELTWISE_THREADS_Y) {\n if (!checkBounds || (readX < height && readY + y < width)) {\n shmem[threadIdx.x][threadIdx.y + y] = op(a[(readY + y) * strideA + readX]);\n }\n }\n __syncthreads();\n\n const uint writeX = bx + threadIdx.x;\n const uint writeY = by + threadIdx.y;\n for (uint y = 0; y < ELTWISE_THREADS_X; y+= ELTWISE_THREADS_Y) {\n if(!checkBounds || (writeX < width && writeY + y < height)) {\n dest[(writeY + y) * strideDest + writeX] = shmem[threadIdx.y + y][threadIdx.x];\n\n }\n }\n __syncthreads();\n }\n }\n}\n\ntemplate\n__global__ void kEltwiseUnaryOpFlat(const float* a, float* const dest, const uint numElements, Op op) {\n const uint idxX = blockIdx.x * ELTWISE_FLAT_THREADS_X + threadIdx.x;\n\n for (uint x = idxX; x < numElements; x += gridDim.x * ELTWISE_FLAT_THREADS_X) {\n dest[x] = op(a[x]);\n }\n}\n\ntemplate\n__global__ void kEltwiseUnaryOp(const float* a, float* const dest, const uint height, const uint width,\n const uint strideA, const uint strideDest, Op op) {\n const uint idxX = blockIdx.x * ELTWISE_THREADS_X + threadIdx.x;\n const uint idxY = blockIdx.y * ELTWISE_THREADS_Y + threadIdx.y;\n\n for (uint y = idxY; y < height; y += gridDim.y * ELTWISE_THREADS_Y) {\n for (uint x = idxX; x < width; x += gridDim.x * ELTWISE_THREADS_X) {\n dest[y * strideDest + x] = op(a[y * strideA + x]);\n }\n }\n}\n\n/*\n * Matrix in ROW-MAJOR order!\n */\ntemplate \n__global__ void kRowVectorOp(const float* mat, const float* vec, float* const tgtMat, const uint width, const uint height,\n const uint matStride, const uint tgtStride, Op op) {\n __shared__ float shVec[ADD_VEC_THREADS_X];\n const uint bx = ADD_VEC_THREADS_X * blockIdx.x;\n const uint by = ADD_VEC_THREADS_Y * blockIdx.y;\n\n for (uint x = bx; x < width; x += gridDim.x * ADD_VEC_THREADS_X) {\n __syncthreads();\n if (x + threadIdx.x < width && threadIdx.y == 0) {\n shVec[threadIdx.x] = vec[x + threadIdx.x];\n }\n __syncthreads();\n\n if (x + threadIdx.x < width) {\n for (uint y = by + threadIdx.y; y < height; y += gridDim.y * ADD_VEC_THREADS_Y) {\n tgtMat[y * tgtStride + x + threadIdx.x] = op(mat[y * matStride + x + threadIdx.x], shVec[threadIdx.x]);\n }\n }\n }\n}\n\n/*\n * Matrix in ROW-MAJOR order!\n */\ntemplate \n__global__ void kColVectorOp(float* mat, float* vec, float* tgtMat,\n const uint width, const uint height,\n const uint matStride, const uint tgtStride, Op op) {\n __shared__ float shVec[ADD_VEC_THREADS_Y];\n const uint by = ADD_VEC_THREADS_Y * blockIdx.y;\n const uint bx = ADD_VEC_THREADS_X * blockIdx.x;\n const uint tidx = ADD_VEC_THREADS_X * threadIdx.y + threadIdx.x;\n \n mat += threadIdx.y * matStride;\n vec += tidx;\n tgtMat += threadIdx.y * tgtStride;\n\n for (uint y = by; y < height; y += gridDim.y * ADD_VEC_THREADS_Y) {\n __syncthreads();\n if (y + tidx < height && tidx < ADD_VEC_THREADS_Y) {\n shVec[tidx] = vec[y];\n }\n __syncthreads();\n\n if (y + threadIdx.y < height) {\n for (uint x = bx + threadIdx.x; x < width; x += gridDim.x * ADD_VEC_THREADS_X) {\n tgtMat[(y) * tgtStride + x] = op(mat[(y) * matStride + x], shVec[threadIdx.y]);\n }\n }\n }\n}\n\n/*\n * This one gets coalesced reads but computes only a partial sum which\n * must either be summed again (recursively) or summed on the host.\n */\ntemplate\n__global__ void kAggRows(const float* mat, float* matSum, const uint width, const uint height, const uint sumWidth, Agg agg, UnaryOp uop, BinaryOp bop) {\n const int idxX = blockIdx.x * blockSize*2 + threadIdx.x;\n\n __shared__ float accum[blockSize*2];\n\n matSum += blockIdx.y * sumWidth + blockIdx.x;\n /*\n * Here it's important to make sure that all threads in a block call __syncthreads,\n * so I have even the redundant threads (for which idxX >= width) enter this loop\n * just so that they may call __syncthreads at the appropriate times.\n */\n mat += width * blockIdx.y + idxX;\n\n accum[threadIdx.x] = agg.getBaseValue();\n accum[threadIdx.x + blockSize] = agg.getBaseValue();\n for (uint idxY = blockIdx.y; idxY < height; idxY += gridDim.y) {\n if (idxX < width) {\n accum[threadIdx.x] = uop(mat[0]);\n if(idxX + blockSize < width)\n accum[threadIdx.x + blockSize] = uop(mat[blockSize]);\n }\n if (blockSize >= 512) {\n __syncthreads();\n if (threadIdx.x < 512)\n accum[threadIdx.x] = agg(accum[threadIdx.x], accum[threadIdx.x + 512]);\n }\n if (blockSize >= 256) {\n __syncthreads();\n if (threadIdx.x < 256)\n accum[threadIdx.x] = agg(accum[threadIdx.x],accum[threadIdx.x + 256]);\n }\n if (blockSize >= 128) {\n __syncthreads();\n if (threadIdx.x < 128)\n accum[threadIdx.x] = agg(accum[threadIdx.x],accum[threadIdx.x + 128]);\n }\n if (blockSize >= 64) {\n __syncthreads();\n if (threadIdx.x < 64)\n accum[threadIdx.x] = agg(accum[threadIdx.x],accum[threadIdx.x + 64]);\n }\n\n __syncthreads();\n volatile float* myAccum = &accum[threadIdx.x];\n if (threadIdx.x < 32) { // executed only by first warp\n myAccum[0] = agg(myAccum[0], myAccum[32]);\n myAccum[0] = agg(myAccum[0], myAccum[16]);\n myAccum[0] = agg(myAccum[0], myAccum[8]);\n myAccum[0] = agg(myAccum[0], myAccum[4]);\n myAccum[0] = agg(myAccum[0], myAccum[2]);\n myAccum[0] = agg(myAccum[0], myAccum[1]);\n }\n\n if (threadIdx.x == 0) {\n matSum[0] = bop(matSum[0], myAccum[0]);\n matSum += gridDim.y * sumWidth;\n }\n __syncthreads();\n mat += width * gridDim.y;\n }\n}\n\ntemplate\n__global__ void kAggRows_wholerow(const float* mat, float* matSum, const uint width, const uint height, Agg agg, BinaryOp op) {\n const int tidx = threadIdx.x;\n\n __shared__ float accum[AWR_NUM_THREADS];\n volatile float* vMyAccum = &accum[tidx];\n float* myAccum = &accum[tidx];\n \n matSum += blockIdx.y;\n mat += width * blockIdx.y;\n\n for (uint idxY = blockIdx.y; idxY < height; idxY += gridDim.y) {\n myAccum[0] = agg.getBaseValue();\n for (uint x = tidx; x < width; x += AWR_NUM_THREADS) {\n myAccum[0] = agg(myAccum[0], mat[x]);\n }\n #pragma unroll\n for (uint i = AWR_LOG_NUM_THREADS - 1; i > LOG_WARP_SIZE; i--) {\n const uint d = 1 << i;\n __syncthreads();\n if (tidx < d) {\n myAccum[0] = agg(myAccum[0], myAccum[d]);\n }\n }\n __syncthreads();\n if (tidx < WARP_SIZE) {\n #pragma unroll\n for (int i = LOG_WARP_SIZE; i >= 0; i--) {\n const uint d = 1 << i;\n vMyAccum[0] = agg(vMyAccum[0], vMyAccum[d]);\n }\n\n if (tidx == 0) {\n matSum[0] = op(matSum[0], vMyAccum[0]);\n matSum += gridDim.y;\n }\n }\n __syncthreads();\n mat += width * gridDim.y;\n }\n}\n\n/*\n * Implements multiscan idea from http://www.moderngpu.com\n * Not really useful for pure reductions but neat nonetheless.\n */\ntemplate\n__global__ void kAggRows_wholerow_nosync(const float* mat, float* matSum, const uint width, const uint height,\n Agg agg, UnaryOp uop, BinaryOp bop) {\n const uint tidx = threadIdx.x;\n const uint warpIdx = tidx / WARP_SIZE;\n const uint lane = tidx % WARP_SIZE;\n \n __shared__ float accum[(WARP_SIZE + 1) * AWR_NUM_WARPS];\n __shared__ float finalAccum[AWR_NUM_WARPS];\n\n float* myAccum = &accum[warpIdx * (WARP_SIZE + 1) + lane];\n float* myFinalAccum = &finalAccum[tidx];\n //volatile float* vMyAccum = &accum[warpIdx * (WARP_SIZE + 1) + lane];\n matSum += blockIdx.y;\n mat += width * blockIdx.y;\n\n float rAccum = agg.getBaseValue(); // cache in register, a bit faster than shmem\n #pragma unroll 32\n for (uint x = tidx; x < width; x += AWR_NUM_THREADS) {\n rAccum = agg(rAccum, uop(mat[x]));\n }\n myAccum[0] = rAccum;\n \n // Each warp does a reduction that doesn't require synchronizatoin\n #pragma unroll\n for (uint i = 0; i < LOG_WARP_SIZE; i++) {\n const uint d = 1 << i;\n myAccum[0] = agg(myAccum[0], shfl_down(myAccum[0], d));\n }\n __syncthreads();\n // The warps write their results\n if (tidx < AWR_NUM_WARPS) {\n //volatile float* vMyFinalAccum = &finalAccum[tidx];\n myFinalAccum[0] = accum[tidx * (WARP_SIZE + 1)];\n #pragma unroll\n for (uint i = 0; i < AWR_LOG_NUM_WARPS; i++) {\n const uint d = 1 << i;\n myFinalAccum[0] = agg(myFinalAccum[0], shfl_down(myFinalAccum[0], d));\n }\n if (tidx == 0) {\n matSum[0] = bop(matSum[0], myFinalAccum[0]);\n matSum += gridDim.y;\n }\n }\n}\n\n/*\n * To be used when the rows are <= 64.\n *\n * TODO: try to reduce reg usage. i think this can be made faster too.\n */\n//#define AGG_SHORT_ROWS_LOOPS_X 4\ntemplate \n__global__ void kAggShortRows(const float* mat, float* matSum, const uint width, const uint height, Agg agg, UnaryOp uop, BinaryOp bop) {\n const uint shmemX = THREADS_X + 1;\n __shared__ float shmem[AGG_SHORT_ROWS_THREADS_Y*shmemX];\n\n const uint tidx = threadIdx.y * THREADS_X + threadIdx.x;\n const uint ty = LOOPS_X == 1 ? tidx / width : threadIdx.y; // when loops==1, width is gonna be smaller than block x dim\n const uint tx = LOOPS_X == 1 ? tidx % width : threadIdx.x;\n const uint bidx = blockIdx.y * gridDim.x + blockIdx.x;\n const uint blockRowIdx = bidx * AGG_SHORT_ROWS_LOOPS_Y * AGG_SHORT_ROWS_THREADS_Y;\n float* shmemWrite = shmem + MUL24(ty, shmemX) + tx;\n matSum += blockRowIdx + tidx;\n// shmem[MUL24(threadIdx.y, shmemX) + threadIdx.x] = 0;\n mat += width * blockRowIdx + MUL24(ty, width) + tx;\n float* shmemWriteZeros = &shmem[MUL24(threadIdx.y,shmemX) + threadIdx.x];\n\n bool doAgg = tidx < AGG_SHORT_ROWS_THREADS_Y ;\n\n if (blockRowIdx < height) {\n#pragma unroll\n for (uint y = 0; y < AGG_SHORT_ROWS_LOOPS_Y*AGG_SHORT_ROWS_THREADS_Y; y += AGG_SHORT_ROWS_THREADS_Y) {\n doAgg &= tidx + y + blockRowIdx < height;\n const bool heightIdxOK = ty < AGG_SHORT_ROWS_THREADS_Y && ty + y + blockRowIdx < height;\n\n shmemWriteZeros[0] = agg.getBaseValue();\n __syncthreads();\n#pragma unroll\n for(uint x = 0; x < LOOPS_X * THREADS_X; x+= THREADS_X) {\n// __syncthreads();\n if (heightIdxOK && x + tx < width) {\n shmemWrite[0] = agg(uop(mat[x]), shmemWrite[0]);\n }\n }\n __syncthreads();\n if (doAgg) {\n /*\n * I tried doing this final sum as a 4-step reduction, with 8 threads\n * per warp participating. It was slightly slower.\n */\n float accum = agg.getBaseValue();\n float* shmemRead = shmem + MUL24(tidx, shmemX);\n // this loops too much if the rows are really short :(\n#pragma unroll\n for (uint i = 0; i < THREADS_X; i++) {\n accum = agg(accum, shmemRead[0]);\n shmemRead++;\n }\n matSum[0] = bop(matSum[0], accum);\n matSum += AGG_SHORT_ROWS_THREADS_Y;\n }\n __syncthreads();\n mat += width * AGG_SHORT_ROWS_THREADS_Y;\n }\n }\n}\n\ntemplate \n__global__ void kAggShortRows2(const float* mat, float* matSum, const uint width, const uint height, Agg agg, UnaryOp uop, BinaryOp bop) {\n const uint shmemX = AGG_SHORT_ROWS_THREADS_X + 1;\n __shared__ float shmem[AGG_SHORT_ROWS_THREADS_Y*shmemX];\n const uint LOOPS_X = DIVUP(width, AGG_SHORT_ROWS_THREADS_X);\n const uint tidx = threadIdx.y * AGG_SHORT_ROWS_THREADS_X + threadIdx.x;\n\n const uint bidx = blockIdx.y * gridDim.x + blockIdx.x;\n const uint blockRowIdx = bidx * AGG_SHORT_ROWS_LOOPS_Y * AGG_SHORT_ROWS_THREADS_Y;\n\n float* shmemWrite = shmem + MUL24(threadIdx.y, shmemX) + threadIdx.x;\n matSum += blockRowIdx + tidx;\n// shmem[MUL24(threadIdx.y, shmemX) + threadIdx.x] = 0;\n mat += width * blockRowIdx + MUL24(threadIdx.y, width) + threadIdx.x;\n\n bool doAgg = tidx < AGG_SHORT_ROWS_THREADS_Y;\n if(blockRowIdx < height) {\n for (uint y = 0; y < AGG_SHORT_ROWS_LOOPS_Y*AGG_SHORT_ROWS_THREADS_Y; y += AGG_SHORT_ROWS_THREADS_Y) {\n doAgg &= tidx + y + blockRowIdx < height;\n const bool heightIdxOK = threadIdx.y + y + blockRowIdx < height;\n float accum = agg.getBaseValue();\n shmemWrite[0] = agg.getBaseValue();\n\n for(uint x = 0; x < LOOPS_X * AGG_SHORT_ROWS_THREADS_X; x+= AGG_SHORT_ROWS_THREADS_X) {\n// __syncthreads();\n if (heightIdxOK && x + threadIdx.x < width) {\n shmemWrite[0] = agg(uop(mat[x]), shmemWrite[0]);\n }\n }\n\n __syncthreads();\n if (doAgg) {\n float* shmemRead = shmem + MUL24(tidx, shmemX);\n\n#pragma unroll\n for (uint i = 0; i < AGG_SHORT_ROWS_THREADS_X; i++) {\n accum = agg(accum, shmemRead[0]);\n shmemRead++;\n }\n\n matSum[0] = bop(matSum[0], accum);\n matSum += AGG_SHORT_ROWS_THREADS_Y;\n }\n __syncthreads();\n mat += width * AGG_SHORT_ROWS_THREADS_Y;\n }\n }\n}\n\n/*\n * Bad when there are few columns.\n */\ntemplate \n__global__ void kDumbAggCols(cudaTextureObject_t mat, float* const vec, const uint width, const uint height, Agg agg, UnaryOp uop, BinaryOp bop) {\n const uint idx = blockIdx.x * blockDim.x + threadIdx.x;\n if (idx < width) {\n float mx = agg.getBaseValue();\n for (uint j = 0; j < height; j++) {\n mx = agg(uop(tex1Dfetch(mat, width * j + idx)), mx);\n }\n vec[idx] = bop(vec[idx], mx);\n }\n}\n\n/*\n * Better with few columns because it only computes a partial sum.\n */\ntemplate \n__global__ void kAggCols(cudaTextureObject_t mat, float* const vec, const uint width, const uint height, const uint sumLength, Agg agg, UnaryOp op) {\n const uint idxX = blockIdx.x * blockDim.x + threadIdx.x;\n const uint idxY = blockIdx.y * sumLength;\n if (idxX < width) {\n float mx = agg.getBaseValue();\n for (uint j = idxY; j < min(height,idxY + sumLength); j++) {\n mx = agg(op(tex1Dfetch(mat, j * width + idxX)), mx);\n }\n vec[blockIdx.y * width + idxX] = mx;\n }\n}\n\ntemplate \n__global__ void kTotalAgg(const float* a, float* const target, const uint numElements, Agg agg) {\n __shared__ float shmem[DP_BLOCKSIZE];\n uint eidx = DP_BLOCKSIZE * blockIdx.x + threadIdx.x;\n shmem[threadIdx.x] = agg.getBaseValue();\n if (eidx < gridDim.x * DP_BLOCKSIZE) {\n for (; eidx < numElements; eidx += gridDim.x * DP_BLOCKSIZE) {\n shmem[threadIdx.x] = agg(shmem[threadIdx.x], a[eidx]);\n }\n }\n __syncthreads();\n if (threadIdx.x < 256) {\n shmem[threadIdx.x] = agg(shmem[threadIdx.x], shmem[threadIdx.x + 256]);\n }\n __syncthreads();\n if (threadIdx.x < 128) {\n shmem[threadIdx.x] = agg(shmem[threadIdx.x], shmem[threadIdx.x + 128]);\n }\n __syncthreads();\n if (threadIdx.x < 64) {\n shmem[threadIdx.x] = agg(shmem[threadIdx.x], shmem[threadIdx.x + 64]);\n }\n __syncthreads();\n if (threadIdx.x < 32) {\n volatile float* mysh = &shmem[threadIdx.x];\n *mysh = agg(*mysh, mysh[32]);\n *mysh = agg(*mysh, mysh[16]);\n *mysh = agg(*mysh, mysh[8]);\n *mysh = agg(*mysh, mysh[4]);\n *mysh = agg(*mysh, mysh[2]);\n *mysh = agg(*mysh, mysh[1]);\n if (threadIdx.x == 0) {\n target[blockIdx.x] = *mysh;\n }\n }\n}\n\nclass AddGaussianUnaryRandomizer {\nprivate:\n const float stdev;\npublic:\n AddGaussianUnaryRandomizer(float _stdev) : stdev(_stdev) {\n }\n __device__ inline float operator ()(float data, curandState* state) {\n return data + stdev * curand_normal(state);\n }\n};\n\nclass BinarizeUnaryRandomizer {\npublic:\n __device__ inline float operator ()(float data, curandState* state) {\n return data > curand_uniform(state);\n }\n};\n\nclass UniformUnaryRandomizer {\npublic:\n __device__ inline float operator ()(float data, curandState* state) {\n return curand_uniform(state);\n }\n};\n\nclass GaussianUnaryRandomizer {\nprivate:\n const float mean, stdev;\npublic:\n GaussianUnaryRandomizer(float _mean, float _stdev) : mean(_mean), stdev(_stdev) {\n }\n __device__ inline float operator ()(float data, curandState* state) {\n return mean + stdev * curand_normal(state);\n }\n};\n\ntemplate \nclass AddGaussianBinaryRandomizer {\npublic:\n __device__ inline float operator ()(float data, float stdev, curandState* state) {\n return data + (var ? stdev : 1) * stdev * curand_normal(state);\n }\n};\n\nclass GaussianBinaryRandomizer {\nprivate:\n const float mean;\npublic:\n GaussianBinaryRandomizer(float _mean) : mean(_mean) {\n }\n __device__ inline float operator ()(float data, float stdev, curandState* state) {\n return mean + stdev * curand_normal(state);\n }\n};\n\nclass ScaledGaussianBinaryRandomizer {\nprivate:\n const float mean, stdevScale;\npublic:\n ScaledGaussianBinaryRandomizer(float _mean, float _stdevScale) : mean(_mean), stdevScale(_stdevScale) {\n }\n __device__ inline float operator ()(float data, float stdev, curandState* state) {\n return mean + stdevScale * stdev * curand_normal(state);\n }\n};\n\ntemplate\n__global__ void kUnaryRandomize(float* data, float* targets, curandState* state, const uint numElements, Randomizer rnd) {\n const uint tidx = NUM_RND_THREADS_PER_BLOCK * blockIdx.x + threadIdx.x;\n curandState localState = state[tidx];\n\n for (uint i = tidx; i < numElements; i += NUM_RND_STREAMS) {\n targets[i] = rnd(data[i], &localState);\n }\n state[tidx] = localState;\n}\n\ntemplate\n__global__ void kBinaryRandomize(float* data, float* data2, float* targets, curandState* state, const uint numElements, Randomizer rnd) {\n const uint tidx = NUM_RND_THREADS_PER_BLOCK * blockIdx.x + threadIdx.x;\n curandState localState = state[tidx];\n\n for (uint i = tidx; i < numElements; i += NUM_RND_STREAMS) {\n targets[i] = rnd(data[i], data2[i], &localState);\n }\n state[tidx] = localState;\n}\n\n#endif /* NVMATRIX_KERNEL_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/include/nvmatrix_operators.cuh", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef NVMATRIX_OPERATORS_CUH\n#define\tNVMATRIX_OPERATORS_CUH\n\nclass NVMatrixOps {\npublic:\n class Exp {\n public:\n __device__ inline float operator()(const float a) const {\n return __expf(a);\n }\n };\n\n class Logistic {\n public:\n __device__ inline float operator()(const float a) const {\n return __fdividef(1.0f, 1.0f + __expf(-a));\n }\n };\n\n class Log {\n public:\n __device__ inline float operator()(const float a) const {\n return __logf(a);\n }\n };\n\n class Square {\n public:\n __device__ inline float operator()(const float a) const {\n return a * a;\n }\n };\n\n class Sqrt {\n public:\n __device__ inline float operator()(const float a) const {\n return sqrtf(a);\n }\n };\n\n class SqrtAbs {\n public:\n __device__ inline float operator()(const float a) const {\n return sqrtf(fabsf(a));\n }\n };\n\n class Reciprocal {\n public:\n __device__ inline float operator()(const float a) const {\n return 1.0f / a;\n }\n };\n\n class Abs {\n public:\n __device__ inline float operator()(const float a) const {\n return a > 0 ? a : -a;\n }\n };\n\n class Sign {\n public:\n __device__ inline float operator()(const float a) const {\n return (a > 0) - (a < 0);\n }\n };\n\n class Identity {\n public:\n __device__ inline float operator()(const float a) const {\n return a;\n }\n };\n\n class Zero {\n public:\n __device__ inline float operator()(const float a) const {\n return 0;\n }\n };\n\n class One {\n public:\n __device__ inline float operator()(const float a) const {\n return 1;\n }\n };\n\n class Const {\n private:\n const float scalar;\n public:\n Const(const float _scalar) : scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return scalar;\n }\n };\n\n class OneMinus {\n public:\n __device__ inline float operator()(const float x) const {\n return 1.0f - x;\n }\n };\n\n class Linear {\n protected:\n float _a, _b;\n public:\n __device__ inline float operator()(float x) const {\n return _a * x + _b;\n }\n Linear(float a, float b) : _a(a), _b(b) {\n }\n };\n\n class IsNan {\n public:\n __device__ inline float operator()(const float a) const {\n return isnan(a);\n }\n };\n\n class IsInf {\n public:\n __device__ inline float operator()(const float a) const {\n return isinf(a);\n }\n };\n\n class SmallerThanScalar {\n private:\n const float scalar;\n public:\n SmallerThanScalar(const float _scalar) : scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return a < scalar;\n }\n };\n\n class BiggerThanScalar {\n private:\n const float scalar;\n public:\n BiggerThanScalar(const float _scalar) : scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return a > scalar;\n }\n };\n\n class AddScalar {\n private:\n const float scalar;\n public:\n AddScalar(const float _scalar) : scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return a + scalar;\n }\n };\n\n class WeightedAddScalar {\n private:\n const float weight, scalar;\n public:\n WeightedAddScalar(const float _weight, const float _scalar) : weight(_weight), scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return weight * a + scalar;\n }\n };\n\n class MultByScalar {\n private:\n const float scalar;\n public:\n MultByScalar(const float _scalar) : scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return a * scalar;\n }\n };\n\n class Pow {\n private:\n const float p;\n public:\n Pow(const float _p) : p(_p) {\n }\n __device__ inline float operator()(const float a) const {\n return __powf(a, p);\n }\n };\n\n template \n class InRange {\n private:\n const float lower, upper;\n public:\n InRange(const float _lower, const float _upper) : lower(_lower), upper(_upper) {\n }\n __device__ inline float operator()(const float a) const {\n return exclusive ? a > lower && a < upper : a >= lower && a <= upper;\n }\n };\n\n class MinWithScalar {\n private:\n const float scalar;\n public:\n MinWithScalar(const float _scalar) : scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return a > scalar ? scalar : a;\n }\n };\n\n class MaxWithScalar {\n private:\n const float scalar;\n public:\n MaxWithScalar(const float _scalar) : scalar(_scalar) {\n }\n __device__ inline float operator()(const float a) const {\n return a > scalar ? a : scalar;\n }\n };\n};\n\nclass NVMatrixBinaryOps {\npublic:\n class BinaryOp {\n public:\n };\n class Equals : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a == b;\n }\n };\n\n class BiggerThan : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a > b;\n }\n };\n\n class Divide : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return __fdividef(a, b);\n }\n };\n\n class DivideAccurate : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a / b;\n }\n };\n\n class DivideSafe : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return b == 0 ? 0 : __fdividef(a, b);\n }\n };\n\n class DivideSafeAccurate : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return b == 0 ? 0 : (a / b);\n }\n };\n\n class Multiply : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a * b;\n }\n };\n\n class SquaredDiff : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return (a - b) * (a - b);\n }\n };\n\n class WeightedAdd : public BinaryOp {\n private:\n const float scaleA, scaleB;\n public:\n WeightedAdd(const float _scaleA, const float _scaleB) : scaleA(_scaleA), scaleB(_scaleB) {\n }\n WeightedAdd() : scaleA(0), scaleB(0) { // Compiler complains about no default constructor?\n }\n __device__ inline float operator()(const float a, const float b) const {\n return a * scaleA + b * scaleB;\n }\n };\n\n class WeightedAdd1 : public BinaryOp {\n private:\n const float scaleB;\n public:\n WeightedAdd1(const float _scaleB) : scaleB(_scaleB) {\n }\n __device__ inline float operator()(const float a, const float b) const {\n return a + b * scaleB;\n }\n };\n\n class ScaledAdd : public BinaryOp {\n private:\n const float scaleB;\n public:\n ScaledAdd(const float _scaleB) : scaleB(_scaleB) {\n }\n __device__ inline float operator()(const float a, const float b) const {\n return a + b * scaleB;\n }\n };\n\n class Add : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a + b;\n }\n };\n\n class First : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a;\n }\n };\n\n class Second : public BinaryOp {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return b;\n }\n };\n\n class SecondScaled : public BinaryOp {\n private:\n const float scale;\n public:\n SecondScaled(const float _scale) : scale(_scale) {\n }\n\n SecondScaled() : scale(0) { // Compiler complains about no default constructor?\n }\n __device__ inline float operator()(const float a, const float b) const {\n return scale * b;\n }\n };\n\n template\n class CompositeSecond : public BinaryOp {\n private:\n UnaryOp _uop;\n BinaryOp _bop;\n public:\n CompositeSecond(UnaryOp uop, BinaryOp bop) : _uop(uop), _bop(bop) {\n\n }\n __device__ inline float operator()(const float a, const float b) const {\n return _bop(a, _uop(b));\n }\n };\n};\n\nclass NVMatrixAggs {\npublic:\n class Sum {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a + b;\n }\n __device__ inline float getBaseValue() {\n return 0;\n }\n };\n\n class Max {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a > b ? a : b;\n }\n __device__ inline float getBaseValue() {\n return -2e38;\n }\n };\n\n class Min {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a > b ? b : a;\n }\n __device__ inline float getBaseValue() {\n return 2e38;\n }\n };\n\n class CountNan {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a + isnan(b);\n }\n __device__ inline float getBaseValue() {\n return 0;\n }\n };\n\n class CountInf {\n public:\n __device__ inline float operator()(const float a, const float b) const {\n return a + isinf(b);\n }\n __device__ inline float getBaseValue() {\n return 0;\n }\n };\n\n template\n class ArgMax {\n private:\n UnaryOperator u;\n public:\n ArgMax(UnaryOperator _u) : u(_u) {\n }\n __device__ inline float operator()(const float a, const float b) const {\n return u(a) > u(b) ? a : b;\n }\n __device__ inline float getBaseValue() {\n return u.getArgMin();\n }\n };\n};\n\nclass NVMatrixTernaryOps {\npublic:\n class Add {\n public:\n __device__ inline float operator()(const float a, const float b, const float c) const {\n return a + b + c;\n }\n };\n class WeightedAdd {\n private:\n const float scaleA, scaleB, scaleC;\n public:\n WeightedAdd(const float _scaleA, const float _scaleB, const float _scaleC) : scaleA(_scaleA), scaleB(_scaleB), scaleC(_scaleC) {\n }\n __device__ inline float operator()(const float a, const float b, const float c) const {\n return a * scaleA + b * scaleB + c * scaleC;\n }\n };\n};\n\n#endif\t/* NVMATRIX_OPERATORS_CUH */\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/src/memory.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/memory.cuh\"\n\nLock MemoryManager::_globalLock;\nstd::map FastMemoryManager::_memoryManagers;\n\nMemoryManager& FastMemoryManager::getInstance(int deviceID) {\n _globalLock.acquire();\n if (_memoryManagers.count(deviceID) == 0) {\n _memoryManagers[deviceID] = (new FastMemoryManager(deviceID))->init();\n }\n MemoryManager& ret = *_memoryManagers[deviceID];\n _globalLock.release();\n return ret;\n}\n\nMemoryManager* CUDAMemoryManager::_memoryManager = NULL;\nMemoryManager& CUDAMemoryManager::getInstance(int deviceID) {\n _globalLock.acquire();\n if (_memoryManager == NULL) {\n _memoryManager = new CUDAMemoryManager();\n }\n _globalLock.release();\n return *_memoryManager;\n}\n\nMemoryManager* CUDAHostMemoryManager::_memoryManager = NULL;\nMemoryManager& CUDAHostMemoryManager::getInstance() {\n _globalLock.acquire();\n if (_memoryManager == NULL) {\n _memoryManager = new CUDAHostMemoryManager();\n }\n _globalLock.release();\n return *_memoryManager;\n}\n\nMemoryManager* FastHostMemoryManager::_memoryManager = NULL;\nMemoryManager& FastHostMemoryManager::getInstance() {\n _globalLock.acquire();\n if (_memoryManager == NULL) {\n _memoryManager = (new FastHostMemoryManager())->init();\n }\n _globalLock.release();\n return *_memoryManager;\n}\n\n\nvoid FastMemoryManager::destroyInstance(int deviceID) {\n _globalLock.acquire();\n if (_memoryManagers.count(deviceID) != 0) {\n delete _memoryManagers[deviceID];\n _memoryManagers.erase(deviceID);\n }\n _globalLock.release();\n}\n\nvoid FastHostMemoryManager::destroyInstance() {\n _globalLock.acquire();\n if (_memoryManager != NULL) {\n delete _memoryManager;\n _memoryManager = NULL;\n }\n _globalLock.release();\n}\n\nvoid CUDAMemoryManager::destroyInstance(int deviceID) {\n _globalLock.acquire();\n if (_memoryManager != NULL) {\n delete _memoryManager;\n _memoryManager = NULL;\n }\n _globalLock.release();\n}\n\nvoid CUDAHostMemoryManager::destroyInstance() {\n _globalLock.acquire();\n if (_memoryManager != NULL) {\n delete _memoryManager;\n _memoryManager = NULL;\n }\n _globalLock.release();\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/src/nvmatrix.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"../include/nvmatrix.cuh\"\n#include \"../include/nvmatrix_operators.cuh\"\n\nusing namespace std;\n\n/*\n * Device random number generator pointers.\n */\n//map NVMatrix::rndGen;\nmap NVMatrix::_rndDevStates;\nmap NVMatrix::_rndDevThreads;\npthread_mutex_t* NVMatrix::_rndMutex = makeMutex();\npthread_mutex_t* NVMatrix::_cublasMutex = makeMutex();\npthread_mutex_t* NVMatrix::_streamMutex = makeMutex();\nstd::map NVMatrix::_cublasHandles;\nstd::map NVMatrix::_defaultStreams;\n\npthread_mutex_t* NVMatrix::makeMutex() {\n pthread_mutex_t* m = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));\n pthread_mutex_init(m, NULL);\n return m;\n}\n/*\n Do not call resize in _init because resize is a virtual function\n which is overridden in base class. Since C++ is retarded and unable\n to call overridden functions from constructors, we shall call resize\n separately from every constructor after calling _init.\n*/\nvoid NVMatrix::_init(bool isTrans) {\n _numRows = 0;\n _numCols = 0;\n _numElements = 0;\n _ownsData = true;\n\n _isTrans = isTrans;\n _memSegment = NULL;\n\n _stride = 0;\n _texObj = 0;\n}\n\nNVMatrix::NVMatrix() : _deleted(false) {\n _init(false);\n}\n\nNVMatrix::NVMatrix(bool isTrans) : _deleted(false) {\n _init(isTrans);\n}\n\nNVMatrix::NVMatrix(int numRows, int numCols, bool isTrans) : _deleted(false) {\n _init(isTrans);\n resize(numRows, numCols);\n}\n\nNVMatrix::NVMatrix(const Matrix& like, bool copy) : _deleted(false) {\n _init(like.isTrans());\n resize(like.getNumRows(), like.getNumCols());\n if (copy) {\n copyFromHost(like);\n }\n}\n\nNVMatrix::NVMatrix(const NVMatrix& like, bool copy) : _deleted(false) {\n _init(like.isTrans());\n resize(like.getNumRows(), like.getNumCols());\n if (copy) {\n like.copy(*this);\n }\n}\n\n/*\n * Initializes NVMatrix with same dimensions as given matrix but\n * does not copy any data.\n */\nNVMatrix::NVMatrix(const NVMatrix& like) : _deleted(false) {\n _init(like.isTrans());\n resize(like.getNumRows(), like.getNumCols());\n}\n\n/*\n * Initializes NVMatrix with same dimensions as given matrix but\n * does not copy any data.\n */\nNVMatrix::NVMatrix(const Matrix& like) : _deleted(false) {\n _init(false);\n resize(like.getNumRows(), like.getNumCols());\n}\n\nNVMatrix::NVMatrix(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans) :\n _numRows(numRows),\n _numCols(numCols),\n _numElements(numRows*numCols),\n _ownsData(false),\n _memSegment(mem),\n _isTrans(isTrans),\n _deleted(false),\n _texObj(0) {\n _stride = stride < 0 ? getLeadingDim() : stride;\n}\n\nNVMatrix::~NVMatrix() {\n if (!_deleted) {\n deallocTexture();\n if(_ownsData && _numElements > 0) {\n dealloc();\n } else {\n // dealloc deletes the mem segment. But if this is a view,\n // then we still need to delete the mem segment object.\n// assert(_memSegment == NULL || _memSegment->getSize() == 0);\n delete _memSegment;\n }\n }\n}\n\nvoid NVMatrix::copyFromHost(const Matrix& hostMatrix) {\n copyFromHost(hostMatrix, false, getDefaultStream());\n}\n\nvoid NVMatrix::copyFromHost(const Matrix& hostMatrix, bool resizeTarget) {\n copyFromHost(hostMatrix, resizeTarget, getDefaultStream());\n}\n\nvoid NVMatrix::copyFromHost(const Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream) {\n if (resizeTarget) {\n resize(hostMatrix);\n } else {\n assert(isSameDims(hostMatrix));\n }\n setTrans(hostMatrix.isTrans());\n\n if (getNumElements() > 0) {\n CUBLAS_CALL(cublasSetMatrixAsync(hostMatrix.getLeadingDim(), hostMatrix.getFollowingDim(), sizeof(float),\n hostMatrix.getData(), hostMatrix.getLeadingDim(), getDevData(), _stride, stream));\n syncStream(stream);\n }\n}\n\nvoid NVMatrix::copyToHost(Matrix& hostMatrix) const {\n copyToHost(hostMatrix, false, getDefaultStream());\n}\n\nvoid NVMatrix::copyToHost(Matrix& hostMatrix, bool resizeTarget) const {\n copyToHost(hostMatrix, resizeTarget, getDefaultStream());\n}\n\nvoid NVMatrix::copyToHost(Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream) const {\n if (resizeTarget) {\n hostMatrix.resize(_numRows, _numCols);\n } else {\n assert(isSameDims(hostMatrix));\n }\n hostMatrix.setTrans(_isTrans);\n\n if (getNumElements() > 0) {\n CUBLAS_CALL(cublasGetMatrixAsync(getLeadingDim(),getFollowingDim(), sizeof(float),\n getDevData(), getStride(), hostMatrix.getData(), hostMatrix.getLeadingDim(), stream));\n syncStream(stream);\n }\n}\n\nvoid NVMatrix::copy(NVMatrix& dest) const {\n copy(dest, getDefaultStream());\n}\n\nvoid NVMatrix::copy(NVMatrix& dest, cudaStream_t stream) const {\n if (&dest != this) {\n if (!isSameDims(dest)) {\n dest.resize(*this);\n }\n copy(dest, 0, -1, 0, -1, 0, 0, stream);\n }\n}\n\nNVMatrix& NVMatrix::copy() const {\n NVMatrix& c = construct();\n copy(c);\n return c;\n}\n\nvoid NVMatrix::rightMult(NVMatrix &b, float scaleAB, NVMatrix &target) {\n rightMult(b, scaleAB, target, getDefaultStream());\n}\n\nvoid NVMatrix::rightMult(NVMatrix &b, float scaleAB, NVMatrix &target, cudaStream_t stream) {\n// if(&target != this && &target != &b) {\n// target.resize(_numRows, b.getNumCols());\n// target.setTrans(true);\n// }\n target.addProduct(*this, b, 0, scaleAB, stream);\n}\n\nvoid NVMatrix::rightMult(NVMatrix &b, float scaleAB) {\n rightMult(b, scaleAB, *this);\n}\n\nvoid NVMatrix::rightMult(NVMatrix &b, NVMatrix& target) {\n rightMult(b, 1, target);\n}\n\nvoid NVMatrix::addProduct(NVMatrix& a, NVMatrix &b, float scaleThis, float scaleAB) {\n addProduct(a, b, scaleThis, scaleAB, getDefaultStream());\n}\n\n/*\n * This will only work if this matrix is in column-major order! In other words,\n * if isTrans() returns true.\n */\nvoid NVMatrix::addProduct(NVMatrix& a, NVMatrix &b, float scaleThis, float scaleAB, cudaStream_t stream) {\n assert(a.getNumCols() == b.getNumRows());\n\n if (scaleThis == 0) {\n resize(a.getNumRows(), b.getNumCols());\n setTrans(true);\n }\n\n assert(this->getNumRows() == a.getNumRows());\n assert(this->getNumCols() == b.getNumCols());\n assert(_isTrans);\n CUBLAS_CALL(cublasSetStream_v2(getCublasHandle(), stream));\n CUBLAS_CALL(cublasSgemm_v2(getCublasHandle(), a.getTransChar(), b.getTransChar(), a.getNumRows(), b.getNumCols(), a.getNumCols(),\n &scaleAB, a.getDevData(), a.getStride(), b.getDevData(), b.getStride(),\n &scaleThis, getDevData(), getStride()));\n}\n\nvoid NVMatrix::addProduct(NVMatrix& a, NVMatrix &b) {\n addProduct(a, b, 1, 1);\n}\n\nvoid NVMatrix::assertSame(NVMatrixV& a) {\n for (int i = 1; i < a.size(); ++i) {\n assert(a[i]->isSameDims(*a[0]));\n assert(a[i]->isTrans() == a[0]->isTrans());\n assert(a[i]->getStride() == a[0]->getStride());\n assert(a[i]->getDataDeviceID() == a[0]->getDataDeviceID());\n }\n}\n\nvoid NVMatrix::batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB,\n const float** aPtrsDev, const float** bPtrsDev, float** tgtPtrsDev) {\n batchedMatrixMultiply(a, b, target, scaleTarget, scaleAB, getDefaultStream(), aPtrsDev, bPtrsDev, tgtPtrsDev);\n}\n\nvoid NVMatrix::batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB) {\n batchedMatrixMultiply(a, b, target, scaleTarget, scaleAB, getDefaultStream());\n}\n\nvoid NVMatrix::batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB, cudaStream_t stream,\n const float** aPtrsDev, const float** bPtrsDev, float** tgtPtrsDev) {\n assert(a.size() == b.size());\n assert(a.size() == target.size());\n assertSame(a);\n assertSame(b);\n assertSame(target);\n\n const int batch = a.size();\n if (batch > 0) {\n const int rows = a[0]->getNumRows(), inner = a[0]->getNumCols(), cols = b[0]->getNumCols();\n\n assert(inner == b[0]->getNumRows());\n assert(target[0]->getNumRows() == rows);\n assert(target[0]->getNumCols() == cols);\n\n const int lda = a[0]->getStride(), ldb = b[0]->getStride(), ldc = target[0]->getStride();\n cublasOperation_t atrans = a[0]->getTransChar(), btrans = b[0]->getTransChar();\n\n CUBLAS_CALL(cublasSetStream_v2(getCublasHandle(), stream));\n CUBLAS_CALL(cublasSgemmBatched(getCublasHandle(), atrans, btrans, rows, cols, inner, &scaleAB, aPtrsDev, lda, bPtrsDev, ldb, &scaleTarget, tgtPtrsDev, ldc, batch));\n }\n}\n\nvoid NVMatrix::batchedMatrixMultiply(NVMatrixV& a, NVMatrixV& b, NVMatrixV& target, float scaleTarget, float scaleAB, cudaStream_t stream) {\n assert(a.size() == b.size());\n assert(a.size() == target.size() || target.size() == 0);\n\n const int batch = a.size();\n if (batch > 0) {\n const int rows = a[0]->getNumRows(), cols = b[0]->getNumCols();\n\n const float* aPtrs[batch], *bPtrs[batch], *tgtPtrs[batch];\n for (int i = 0; i < batch; ++i) {\n if (target.size() <= i) {\n target.push_back(new NVMatrix(rows, cols, true));\n }\n aPtrs[i] = a[i]->getDevData();\n bPtrs[i] = b[i]->getDevData();\n tgtPtrs[i] = target[i]->getDevData();\n }\n\n// const float** aPtrsDev, **bPtrsDev;\n// float **tgtPtrsDev;\n// checkCudaErrors(cudaMalloc(&aPtrsDev, batch * sizeof(float*)));\n// checkCudaErrors(cudaMalloc(&bPtrsDev, batch * sizeof(float*)));\n// checkCudaErrors(cudaMalloc(&tgtPtrsDev, batch * sizeof(float*)));\n MemorySegment* aPtrsDev = DEVICE_MEMORY_MANAGER::getInstance(getDeviceID()).malloc(batch * sizeof(float*));\n MemorySegment* bPtrsDev = DEVICE_MEMORY_MANAGER::getInstance(getDeviceID()).malloc(batch * sizeof(float*));\n MemorySegment* tgtPtrsDev = DEVICE_MEMORY_MANAGER::getInstance(getDeviceID()).malloc(batch * sizeof(float*));\n\n checkCudaErrors(cudaMemcpyAsync(aPtrsDev, aPtrs, batch * sizeof(float*), cudaMemcpyHostToDevice, stream));\n checkCudaErrors(cudaMemcpyAsync(bPtrsDev, bPtrs, batch * sizeof(float*), cudaMemcpyHostToDevice, stream));\n checkCudaErrors(cudaMemcpyAsync(tgtPtrsDev, tgtPtrs, batch * sizeof(float*), cudaMemcpyHostToDevice, stream));\n\n batchedMatrixMultiply(a, b, target, scaleTarget, scaleAB, stream, const_cast(aPtrsDev->getData()),\n const_cast(bPtrsDev->getData()),\n tgtPtrsDev->getData());\n\n// checkCudaErrors(cudaFree(aPtrsDev));\n// checkCudaErrors(cudaFree(bPtrsDev));\n// checkCudaErrors(cudaFree(tgtPtrsDev));\n DEVICE_MEMORY_MANAGER::getInstance(getDeviceID()).free(aPtrsDev);\n DEVICE_MEMORY_MANAGER::getInstance(getDeviceID()).free(bPtrsDev);\n DEVICE_MEMORY_MANAGER::getInstance(getDeviceID()).free(tgtPtrsDev);\n }\n}\n\ntemplate \nvoid NVMatrix::_unaryRandomize(NVMatrix& target, Randomizer rnd) {\n _unaryRandomize(target, rnd, getDefaultStream());\n}\n\ntemplate \nvoid NVMatrix::_unaryRandomize(NVMatrix& target, Randomizer rnd, cudaStream_t stream) {\n assert(isRndInitialized());\n assert(isContiguous() && target.isContiguous());\n if (!isSameDims(target)) {\n target.resize(*this);\n }\n assert(isTrans() == target.isTrans());\n kUnaryRandomize<<>>(getDevData(), target.getDevData(), getCurandState(), getNumElements(), rnd);\n getLastCudaError(\"kUnaryRandomize: Kernel execution failed\");\n}\n\ntemplate \nvoid NVMatrix::_binaryRandomize(NVMatrix& data2, NVMatrix& target, Randomizer rnd) {\n _binaryRandomize(data2, target, rnd, getDefaultStream());\n}\n\ntemplate \nvoid NVMatrix::_binaryRandomize(NVMatrix& data2, NVMatrix& target, Randomizer rnd, cudaStream_t stream) {\n assert(isRndInitialized());\n assert(isContiguous() && data2.isContiguous() && target.isContiguous());\n assert(isSameDims(data2));\n assert(isTrans() == data2.isTrans());\n if (!isSameDims(target)) {\n target.resize(*this);\n }\n assert(isTrans() == target.isTrans());\n kBinaryRandomize<<>>(getDevData(), data2.getDevData(), target.getDevData(), getCurandState(), getNumElements(), rnd);\n getLastCudaError(\"kBinaryRandomize: Kernel execution failed\");\n}\n\nvoid NVMatrix::initRandom(unsigned long long seed, int numStreams) {\n NVMatrix::initRandom(seed, numStreams, NVMatrix::getDefaultStream());\n}\n\nvoid NVMatrix::initRandom(unsigned long long seed, int numStreams, cudaStream_t stream) {\n// printf(\"init random on device %d\\n\", getDeviceID());\n pthread_mutex_lock(_rndMutex);\n assert(!isRndInitialized(true));\n int d = getDeviceID();\n// _rndDevStates[d] = NULL;\n _rndDevThreads[d] = numStreams;\n _rndDevStates[d] = DEVICE_MEMORY_MANAGER::getInstance(d).malloc(numStreams * sizeof(curandState));\n// checkCudaErrors(cudaMalloc((void **)&_rndDevStates[d], numStreams * sizeof(curandState)));\n pthread_mutex_unlock(_rndMutex);\n kSetupCurand<<>>(getCurandState(), 1 + seed*2); // so there's no chance it'll be correlated with the other one\n getLastCudaError(\"kSetupCurand: Kernel execution failed\");\n}\n\nvoid NVMatrix::initRandom(unsigned long long seed) {\n initRandom(seed, NUM_RND_STREAMS);\n}\n\nvoid NVMatrix::initRandom() {\n NVMatrix::initRandom(time(0));\n}\n\nvoid NVMatrix::initCublas() {\n int d = getDeviceID();\n pthread_mutex_lock(_cublasMutex);\n assert(_cublasHandles.count(d) == 0);\n CUBLAS_CALL(cublasCreate(&_cublasHandles[d]));\n // It appears that cublasCreate causes a host -> device copy on stream 0,\n // so we synchronize with it because we run everything else on other\n // streams.\n syncDevice();\n pthread_mutex_unlock(_cublasMutex);\n}\n\nvoid NVMatrix::destroyCublas() {\n int d = getDeviceID();\n pthread_mutex_lock(_cublasMutex);\n assert(_cublasHandles.count(d) > 0);\n CUBLAS_CALL(cublasDestroy(_cublasHandles[d]));\n _cublasHandles.erase(d);\n pthread_mutex_unlock(_cublasMutex);\n}\n\ncublasHandle_t NVMatrix::getCublasHandle() {\n return getCublasHandle(getDeviceID());\n}\n\ncublasHandle_t NVMatrix::getCublasHandle(int deviceID) {\n pthread_mutex_lock(_cublasMutex);\n assert(_cublasHandles.count(deviceID) > 0);\n cublasHandle_t h = _cublasHandles[deviceID];\n pthread_mutex_unlock(_cublasMutex);\n return h;\n}\n\ncudaStream_t NVMatrix::getDefaultStream() {\n return getDefaultStream(NVMatrix::getDeviceID());\n}\n\ncudaStream_t NVMatrix::getDefaultStream(int deviceID) {\n if (deviceID >= 0) {\n pthread_mutex_lock(_streamMutex);\n if (_defaultStreams.count(deviceID) == 0) {\n int oldDeviceID = getDeviceID();\n NVMatrix::setDeviceID(deviceID);\n checkCudaErrors(cudaStreamCreateWithFlags(&_defaultStreams[deviceID], cudaStreamNonBlocking));\n NVMatrix::setDeviceID(oldDeviceID);\n }\n cudaStream_t s = _defaultStreams[deviceID];\n pthread_mutex_unlock(_streamMutex);\n return s;\n }\n return 0;\n}\n\nvoid NVMatrix::syncDevice() {\n checkCudaErrors(cudaDeviceSynchronize());\n}\n\nvoid NVMatrix::syncStream(cudaStream_t stream) {\n checkCudaErrors(cudaStreamSynchronize(stream));\n}\n\nvoid NVMatrix::syncStream() {\n syncStream(getDefaultStream());\n}\n\ncurandState* NVMatrix::getCurandState() {\n /*\n * Even though we're only reading from the map here, it's important to grab\n * the mutex because another thread may be writing to it.\n */\n pthread_mutex_lock(_rndMutex);\n int d = getDeviceID();\n assert(isRndInitialized(true));\n curandState* r = _rndDevStates[d]->getData();\n pthread_mutex_unlock(_rndMutex);\n return r;\n}\n\ncurandState* NVMatrix::getCurandState(int numStreams) {\n int d = getDeviceID();\n pthread_mutex_lock(_rndMutex);\n assert(isRndInitialized(true));\n bool realloc = numStreams > _rndDevThreads[d];\n pthread_mutex_unlock(_rndMutex);\n\n if (realloc) {\n destroyRandom();\n initRandom(time(0), numStreams);\n }\n return getCurandState();\n}\n\nint NVMatrix::getDataDeviceID() const {\n if (getDevData() == NULL) {\n return DEVICE_NULL;\n }\n struct cudaPointerAttributes atts;\n checkCudaErrors(cudaPointerGetAttributes(&atts, getDevData()));\n return atts.memoryType == cudaMemoryTypeDevice ? atts.device : DEVICE_HOST;\n}\n\n\nint NVMatrix::getDeviceID() {\n int d;\n checkCudaErrors(cudaGetDevice(&d));\n// if (d == 0) {\n// raise(SIGABRT);\n// }\n return d;\n}\n\nvoid NVMatrix::setDeviceID(int d) {\n assert(d >= 0);\n// printf(\"Setting device to %d\\n\", d);\n// if (d == 0) {\n// raise(SIGABRT);\n// }\n checkCudaErrors(cudaSetDevice(d));\n}\n\nbool NVMatrix::canAccessPeer(int srcDevice, int tgtDevice) {\n if (srcDevice == tgtDevice) {\n return true;\n }\n int canAccess;\n checkCudaErrors(cudaDeviceCanAccessPeer(&canAccess, srcDevice, tgtDevice));\n return canAccess;\n}\n\nbool NVMatrix::isRndInitialized(bool haveLock) {\n if (!haveLock) {\n pthread_mutex_lock(_rndMutex);\n }\n bool b = _rndDevStates.count(getDeviceID()) != 0;\n if (!haveLock) {\n pthread_mutex_unlock(_rndMutex);\n }\n return b;\n}\n\nbool NVMatrix::isRndInitialized() {\n return isRndInitialized(false);\n}\n\nvoid NVMatrix::destroyRandom() {\n int d = getDeviceID();\n pthread_mutex_lock(_rndMutex);\n assert(isRndInitialized(true));\n// checkCudaErrors(cudaFree(_rndDevStates[d]));\n DEVICE_MEMORY_MANAGER::getInstance(d).free(_rndDevStates[d]);\n _rndDevStates.erase(d);\n _rndDevThreads.erase(d);\n pthread_mutex_unlock(_rndMutex);\n}\n\nvoid NVMatrix::binarizeProbs() {\n binarizeProbs(*this);\n}\n\nvoid NVMatrix::binarizeProbs(NVMatrix& target) {\n _unaryRandomize(target, BinarizeUnaryRandomizer());\n}\n\nvoid NVMatrix::randomizeUniform() {\n assert(isContiguous());\n assert(isRndInitialized());\n// CURAND_CALL(curandGenerateUniform(rndGen, _devData, getNumElements()));\n _unaryRandomize(*this, UniformUnaryRandomizer());\n}\n\nvoid NVMatrix::randomizeGaussian() {\n randomizeGaussian(1);\n}\n\nvoid NVMatrix::randomizeGaussian(float stdev) {\n randomizeGaussian(0, stdev);\n}\n\nvoid NVMatrix::randomizeGaussian(float mean, float stdev) {\n assert(isContiguous());\n assert(isRndInitialized());\n// CURAND_CALL(curandGenerateNormal(rndGen, _devData, getNumElements(), mean, stdev));\n _unaryRandomize(*this, GaussianUnaryRandomizer(mean, stdev));\n}\n\n/*\n * Kind of a hack since we don't actually need the contents of this matrix for it,\n * so we don't really need a binary randomizer.\n */\nvoid NVMatrix::randomizeGaussian(NVMatrix& stdevs) {\n randomizeGaussian(0, stdevs);\n}\n\nvoid NVMatrix::randomizeGaussian(float mean, NVMatrix& stdevs) {\n _binaryRandomize(stdevs, *this, GaussianBinaryRandomizer(mean));\n}\n\nvoid NVMatrix::randomizeGaussian(float mean, float stdevMult, NVMatrix& stdevs) {\n _binaryRandomize(stdevs, *this, ScaledGaussianBinaryRandomizer(mean, stdevMult));\n}\n\nvoid NVMatrix::addGaussianNoise() {\n addGaussianNoise(1);\n}\n\nvoid NVMatrix::addGaussianNoise(float stdev) {\n addGaussianNoise(stdev, *this);\n}\n\nvoid NVMatrix::addGaussianNoise(float stdev, NVMatrix& target) {\n _unaryRandomize(target, AddGaussianUnaryRandomizer(stdev));\n}\n\nvoid NVMatrix::addGaussianNoise(NVMatrix& stdevs, bool var) {\n addGaussianNoise(stdevs, var, *this);\n}\n\nvoid NVMatrix::addGaussianNoise(NVMatrix& stdevs) {\n addGaussianNoise(stdevs, false, *this);\n}\n\nvoid NVMatrix::addGaussianNoise(NVMatrix& stdevs, bool var, NVMatrix& target) {\n if (var) {\n _binaryRandomize(stdevs, target, AddGaussianBinaryRandomizer());\n } else {\n _binaryRandomize(stdevs, target, AddGaussianBinaryRandomizer());\n }\n}\n\nvoid NVMatrix::biggerThan(NVMatrix& b, NVMatrix& target) {\n applyBinary(NVMatrixBinaryOps::BiggerThan(), b, target);\n}\n\nvoid NVMatrix::biggerThan(NVMatrix& b) {\n biggerThan(b, *this);\n}\n\nvoid NVMatrix::equals(NVMatrix& b, NVMatrix& target) {\n applyBinary(NVMatrixBinaryOps::Equals(), b, target);\n}\n\nvoid NVMatrix::equals(NVMatrix& m) {\n equals(m, *this);\n}\n\nvoid NVMatrix::biggerThanVector(NVMatrix& vec, NVMatrix& target) {\n applyBinaryV(NVMatrixBinaryOps::BiggerThan(), vec, target);\n}\n\nvoid NVMatrix::biggerThanVector(NVMatrix& vec) {\n biggerThanVector(vec, *this);\n}\n\nvoid NVMatrix::_checkBounds(int startRow, int endRow, int startCol, int endCol) const {\n assert(startRow >= 0 && startRow <= _numRows);\n assert(endRow >= startRow && endRow <= _numRows);\n\n assert(startCol >= 0 && startCol <= _numCols);\n assert(endCol >= startCol && endCol <= _numCols);\n}\n\n/*\n * The only place where stride is supported for now!\n * Will ALWAYS return a view of the original data, sometimes non-contiguous.\n */\nNVMatrix& NVMatrix::slice(int startRow, int endRow, int startCol, int endCol) const {\n endRow = endRow < 0 ? this->_numRows : endRow;\n endCol = endCol < 0 ? this->_numCols : endCol;\n _checkBounds(startRow, endRow, startCol, endCol);\n\n if (!isTrans()) {\n return construct(new MemorySegment(this->getDevData() + startRow * _stride + startCol), endRow - startRow, endCol - startCol, _stride, false);\n }\n return construct(new MemorySegment(this->getDevData() + startCol * _stride + startRow), endRow - startRow, endCol - startCol, _stride, true);\n}\n\n/* this will NEVER return a view */\nvoid NVMatrix::slice(int startRow, int endRow, int startCol, int endCol, NVMatrix& target) const {\n endRow = endRow < 0 ? this->_numRows : endRow;\n endCol = endCol < 0 ? this->_numCols : endCol;\n _checkBounds(startRow, endRow, startCol, endCol);\n\n int sliceRows = endRow - startRow, sliceCols = endCol - startCol;\n if (target.getNumRows() != sliceRows || target.getNumCols() != sliceCols) {\n target.resize(sliceRows, sliceCols);\n }\n this->copy(target, startRow, endRow, startCol, endCol, 0, 0);\n}\n\nNVMatrix& NVMatrix::sliceRows(int startRow, int endRow) const {\n return slice(startRow, endRow, 0, -1);\n}\n\nvoid NVMatrix::sliceRows(int startRow, int endRow, NVMatrix& target) const {\n slice(startRow, endRow, 0, -1, target);\n}\n\nNVMatrix& NVMatrix::sliceCols(int startCol, int endCol) const {\n return slice(0, -1, startCol, endCol);\n}\n\nvoid NVMatrix::sliceCols(int startCol, int endCol, NVMatrix& target) const {\n slice(0, -1, startCol, endCol, target);\n}\n\nNVMatrixV& NVMatrix::splitRows(int numParts) {\n assert(getNumRows() % numParts == 0);\n NVMatrixV& v = *new NVMatrixV();\n int partSize = getNumRows() / numParts;\n for (int p = 0; p < numParts; ++p) {\n v.push_back(&sliceRows(p * partSize, (p+1) * partSize));\n }\n return v;\n}\n\nNVMatrixV& NVMatrix::splitCols(int numParts) {\n assert(getNumCols() % numParts == 0);\n NVMatrixV& v = *new NVMatrixV();\n int partSize = getNumCols() / numParts;\n for (int p = 0; p < numParts; ++p) {\n v.push_back(&sliceCols(p * partSize, (p+1) * partSize));\n }\n return v;\n}\n\n/*\n * Guaranteed to not change the data if the number of elements doesn't change.\n * So you can use this to \"reshape\" a matrix.\n */\nbool NVMatrix::resize(int numRows, int numCols, bool trans) {\n setTrans(trans);\n bool reallocated = false;\n if (numRows != _numRows || numCols != _numCols) {\n assert(_ownsData || (_numElements == numRows * numCols && isContiguous()));\n if (_numElements != numRows * numCols) {\n if (_numElements > 0) { // free old memory\n dealloc();\n }\n if (numRows * numCols > 0) { // allocate new memory\n alloc(numCols * numRows);\n } else {\n _memSegment = NULL;\n }\n reallocated = true;\n }\n _numRows = numRows;\n _numCols = numCols;\n _numElements = numRows * numCols;\n _stride = getLeadingDim();\n }\n return reallocated;\n}\n\nbool NVMatrix::resize(int numRows, int numCols) {\n return resize(numRows, numCols, isTrans());\n}\n\nbool NVMatrix::resize(const NVMatrix& like) {\n setTrans(like.isTrans());\n return resize(like.getNumRows(), like.getNumCols());\n}\n\nbool NVMatrix::resize(const Matrix& like) {\n setTrans(like.isTrans());\n return resize(like.getNumRows(), like.getNumCols());\n}\n\nvoid NVMatrix::reshape(int numRows, int numCols) {\n assert(isContiguous());\n assert(_numElements == numRows*numCols);\n _numRows = numRows;\n _numCols = numCols;\n _stride = getLeadingDim();\n}\n\nNVMatrix& NVMatrix::reshaped(int numRows, int numCols) const {\n assert(isContiguous());\n assert(_numElements == numRows*numCols);\n return construct(new MemorySegment(*_memSegment), numRows, numCols, -1, _isTrans);\n}\n\nvoid NVMatrix::copy(NVMatrix &dest, int srcStartRow, int srcEndRow,\n int srcStartCol, int srcEndCol,\n int destStartRow, int destStartCol) const {\n copy(dest, srcStartRow, srcEndRow, srcStartCol, srcEndCol, destStartRow, destStartCol, getDefaultStream());\n}\n\nvoid NVMatrix::copy(NVMatrix &dest, int srcStartRow, int srcEndRow,\n int srcStartCol, int srcEndCol,\n int destStartRow, int destStartCol, cudaStream_t stream) const {\n srcEndRow = srcEndRow < 0 ? _numRows : srcEndRow;\n srcEndCol = srcEndCol < 0 ? _numCols : srcEndCol;\n NVMatrix* srcSlice = &slice(srcStartRow, srcEndRow, srcStartCol, srcEndCol);\n NVMatrix* destSlice = &dest.slice(destStartRow, destStartRow + srcEndRow - srcStartRow, destStartCol, destStartCol + srcEndCol - srcStartCol);\n if (srcSlice->isContiguous() && destSlice->isContiguous() && srcSlice->isSameDims(*destSlice) && srcSlice->isTrans() == destSlice->isTrans()) {\n // The commonest case.\n checkCudaErrors(cudaMemcpyAsync(destSlice->getDevData(), srcSlice->getDevData(), srcSlice->getNumDataBytes(), cudaMemcpyDefault, stream));\n } else {\n srcSlice->apply(NVMatrixOps::Identity(), *destSlice, stream);\n }\n delete srcSlice;\n delete destSlice;\n}\n\n\nNVMatrix& NVMatrix::getTranspose() {\n return construct(new MemorySegment(*_memSegment), _numCols, _numRows, _stride, !_isTrans);\n}\n\nNVMatrix& NVMatrix::getClone() {\n return construct(new MemorySegment(*_memSegment), _numRows, _numCols, _stride, _isTrans);\n}\n\nvoid NVMatrix::transpose(NVMatrix& target) {\n flipTrans(target);\n target.setTrans(!target.isTrans());\n target.reshape(target.getNumCols(), target.getNumRows());\n}\n\nvoid NVMatrix::transpose() {\n int tmp = _numCols;\n _numCols = _numRows;\n _numRows = tmp;\n _isTrans = !_isTrans;\n}\n\nbool NVMatrix::transpose(bool trans) {\n bool oldTrans = _isTrans;\n if (oldTrans != trans) {\n transpose();\n }\n return oldTrans;\n}\n\n/*\n * Flips the ordering of the matrix from row-major to column-major and vice versa.\n * This creates temporary storage -- not a cheap operation.\n *\n * This is not equivalent to a \"hard transpose\". The resultant matrix still has\n * the same dimensions, its layout in memory just changes.\n */\nNVMatrix& NVMatrix::flipTrans() {\n NVMatrix& meTrans = construct(*this);\n flipTrans(meTrans);\n return meTrans;\n}\n\nvoid NVMatrix::flipTrans(NVMatrix& target) {\n flipTrans(target, getDefaultStream());\n}\n\nvoid NVMatrix::flipTrans(NVMatrix& target, cudaStream_t stream) {\n assert(&target != this);\n target.resize(_numRows, _numCols);\n target.setTrans(!isTrans());\n// target.printShape(\"target\");\n// this->printShape(\"this\");\n apply(NVMatrixOps::Identity(), target, stream);\n}\n\nvoid NVMatrix::squaredDiff(NVMatrix& b) {\n squaredDiff(b, *this);\n}\n\nvoid NVMatrix::squaredDiff(NVMatrix& b, NVMatrix& target) {\n applyBinary(NVMatrixBinaryOps::SquaredDiff(), b, target);\n}\n\nvoid NVMatrix::add(NVMatrix& b, float scaleA, float scaleB, NVMatrix& target) {\n add(b, scaleA, scaleB, target, NVMatrix::getDefaultStream());\n}\n\nvoid NVMatrix::add(NVMatrix& b, float scaleA, float scaleB, NVMatrix& target, cudaStream_t stream) {\n if (scaleA == 0) {\n b.scale(scaleB, target, stream);\n } else if (scaleB == 0) {\n scale(scaleA, target, stream);\n } else if (scaleA == 1 && scaleB == 1) { // slight optimization\n applyBinary(NVMatrixBinaryOps::Add(), b, target, stream);\n } else if (scaleA == 1) {\n applyBinary(NVMatrixBinaryOps::WeightedAdd1(scaleB), b, target, stream);\n } else {\n applyBinary(NVMatrixBinaryOps::WeightedAdd(scaleA, scaleB), b, target, stream);\n }\n}\n\nvoid NVMatrix::add(NVMatrix& b, float scaleB, NVMatrix& target) {\n add(b, 1, scaleB, target);\n}\n\nvoid NVMatrix::add(NVMatrix& b, NVMatrix& target) {\n add(b, 1, target);\n}\n\nvoid NVMatrix::add(NVMatrix& b, float scaleB) {\n add(b, scaleB, *this);\n}\n\nvoid NVMatrix::add(NVMatrix& b, float scaleA, float scaleB) {\n add(b, scaleA, scaleB, *this);\n}\n\nvoid NVMatrix::add(NVMatrix& b) {\n add(b, 1, *this);\n}\n\nvoid NVMatrix::subtract(NVMatrix& b, NVMatrix& target) {\n add(b, -1, target);\n}\n\nvoid NVMatrix::subtract(NVMatrix& b) {\n add(b, -1);\n}\n\nvoid NVMatrix::eltwiseMult(NVMatrix& b, NVMatrix& target) {\n applyBinary(NVMatrixBinaryOps::Multiply(), b, target);\n}\n\nvoid NVMatrix::eltwiseMult(NVMatrix& b) {\n eltwiseMult(b, *this);\n}\n\nvoid NVMatrix::eltwiseDivide(NVMatrix& b, NVMatrix& target) {\n applyBinary(NVMatrixBinaryOps::Divide(), b, target);\n}\n\nvoid NVMatrix::eltwiseDivide(NVMatrix& b) {\n eltwiseDivide(b, *this);\n}\n\nvoid NVMatrix::tile(int timesY, int timesX, NVMatrix& target) {\n tile(timesY, timesX, target, getDefaultStream());\n}\n\nvoid NVMatrix::tile(int timesY, int timesX, NVMatrix& target, cudaStream_t stream) {\n assert(isContiguous() && target.isContiguous());\n assert(timesX > 0 && timesY > 0);\n target.resize(_numRows*timesY, _numCols*timesX);\n target.setTrans(_isTrans);\n if(!isTrans()) {\n kTile<<>>(getDevData(), target.getDevData(), _numCols, _numRows, target._numCols, target._numRows);\n } else {\n kTile<<>>(getDevData(), target.getDevData(), _numRows, _numCols, target._numRows, target._numCols);\n }\n getLastCudaError(\"Kernel execution failed\");\n}\n\nvoid NVMatrix::addVector(NVMatrix& vec, float scaleVec, NVMatrix& target) {\n addVector(vec, scaleVec, target, getDefaultStream());\n}\n\nvoid NVMatrix::addVector(NVMatrix& vec, float scaleVec, NVMatrix& target, cudaStream_t stream) {\n applyBinaryV(NVMatrixBinaryOps::ScaledAdd(scaleVec), vec, target, stream);\n}\n\nvoid NVMatrix::addVector(NVMatrix& vec) {\n addVector(vec, 1);\n}\n\nvoid NVMatrix::addVector(NVMatrix& vec, float scaleVec) {\n addVector(vec, scaleVec, *this);\n}\n\nvoid NVMatrix::addVector(NVMatrix& vec, NVMatrix& target) {\n addVector(vec, 1, target);\n}\n\nvoid NVMatrix::equalsVector(NVMatrix& vec, NVMatrix& target) {\n applyBinaryV(NVMatrixBinaryOps::Equals(), vec, target);\n}\n\nvoid NVMatrix::equalsVector(NVMatrix& vec) {\n equalsVector(vec, *this);\n}\n\nvoid NVMatrix::eltwiseMultByVector(NVMatrix& vec, NVMatrix& target) {\n eltwiseMultByVector(vec, target, getDefaultStream());\n}\n\nvoid NVMatrix::eltwiseMultByVector(NVMatrix& vec, NVMatrix& target, cudaStream_t stream) {\n applyBinaryV(NVMatrixBinaryOps::Multiply(), vec, target, stream);\n}\n\nvoid NVMatrix::eltwiseMultByVector(NVMatrix& vec, cudaStream_t stream) {\n eltwiseMultByVector(vec, *this, stream);\n}\n\nvoid NVMatrix::eltwiseMultByVector(NVMatrix& vec) {\n eltwiseMultByVector(vec, *this);\n}\n\nvoid NVMatrix::eltwiseDivideByVector(NVMatrix& vec) {\n eltwiseDivideByVector(vec, *this);\n}\n\nvoid NVMatrix::eltwiseDivideByVector(NVMatrix& vec, NVMatrix& target) {\n applyBinaryV(NVMatrixBinaryOps::Divide(), vec, target);\n}\n\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop, cudaStream_t stream) {\n _aggregate(axis, target, agg, uop, bop, stream, NULL);\n}\n\n/*\n * TODO: this is a mess, fix it. it works pretty fast but it's too ugly.\n * TODO: this function is _really_ bad for very long aggregations of few columns.\n */\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop, cudaStream_t stream, NVMatrix* tmp) {\n assert(axis == 0 || axis == 1);\n assert(isContiguous() && target.isContiguous());\n assert(&target != this);\n int width = _isTrans ? _numRows : _numCols;\n int height = _isTrans ? _numCols : _numRows;\n\n target.setTrans(_isTrans);\n assert(width > 0);\n assert(height > 0);\n if((axis == 0 && !_isTrans) || (axis == 1 && _isTrans)) { //col sum\n target.resize(!_isTrans ? 1 : _numRows, !_isTrans ? _numCols : 1);\n// int height = getFollowingDim();\n if ((height <= 2048 || width >= 4096)) {\n int numBlocks = DIVUP(width, NUM_SUM_COLS_THREADS_PER_BLOCK);\n assert(numBlocks * NUM_SUM_COLS_THREADS_PER_BLOCK >= width);\n assert(numBlocks < NUM_BLOCKS_MAX);\n kDumbAggCols<<>>(getTextureObject(), target.getDevData(), width, height, agg, uop, bop);\n getLastCudaError(\"kDumbAggCols: Kernel execution failed\");\n } else { // Specialize the case when we have very long columns and few of them\n const int sumLength = 128;\n bool deltmp = tmp == NULL;\n if (tmp == NULL) {\n tmp = new NVMatrix(false);\n }\n\n int numBlocksX = DIVUP(width, NUM_SUM_COLS_THREADS_PER_BLOCK);\n int numBlocksY = DIVUP(height, sumLength);\n tmp->resize(numBlocksY, width);\n\n dim3 blocks(numBlocksX, numBlocksY);\n dim3 threads(NUM_SUM_COLS_THREADS_PER_BLOCK);\n kAggCols<<>>(getTextureObject(), tmp->getDevData(), width, height, sumLength, agg, uop);\n getLastCudaError(\"kAggCols: Kernel execution failed\");\n\n int numBlocks = DIVUP(width, NUM_SUM_COLS_THREADS_PER_BLOCK);\n kDumbAggCols<<>>(tmp->getTextureObject(), target.getDevData(), width, numBlocksY, agg, NVMatrixOps::Identity(), bop);\n getLastCudaError(\"kDumbAggCols: Kernel execution failed\");\n if (deltmp) {\n delete tmp;\n }\n }\n } else { // row sum\n target.resize(_isTrans ? 1 : _numRows, _isTrans ? _numCols : 1);\n if (width > 1) {\n if (height >= 16384) { // linear aggregation\n int numBlocksX = 1;\n int numBlocksY = DIVUP(height, AGG_SHORT_ROWS_THREADS_Y*AGG_SHORT_ROWS_LOOPS_Y);\n int numThreadsX = width <= 4 ? 4 : width <= 8 ? 8 : width <= 12 ? 12 : width <= 16 ? 16 : AGG_SHORT_ROWS_THREADS_X;\n int numThreadsY = AGG_SHORT_ROWS_THREADS_Y;\n while (numBlocksY > NUM_BLOCKS_MAX) {\n numBlocksY = DIVUP(numBlocksY,2);\n numBlocksX *= 2;\n }\n dim3 grid(numBlocksX, numBlocksY), threads(numThreadsX, numThreadsY);\n if(width <= 16) {\n if(width <= 4) {\n kAggShortRows<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n } else if(width <= 8) {\n kAggShortRows<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n } else if(width <= 12) {\n kAggShortRows<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n } else {\n kAggShortRows<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n }\n } else if(width <= 32) {\n kAggShortRows<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n } else if(width <= 48){\n kAggShortRows<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n } else if(width <= 64){\n kAggShortRows<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n } else {\n kAggShortRows2<<>>(getDevData(), target.getDevData(),width, height, agg, uop, bop);\n }\n } else {\n if (width >= 512) {\n // NOTE: this is the only case which I bothered to try to optimize for Kepler\n dim3 threads(AWR_NUM_THREADS);\n dim3 blocks(1, height);\n kAggRows_wholerow_nosync<<>>(getDevData(), target.getDevData(), width, height, agg, uop, bop);\n } else {\n\n int numThreadsX = width <= 64 ? 32 : (width <= 128 ? 64 : (width <= 256 ? 128 : (width <= 512 ? 256 : 512)));\n int numThreadsY = 1;\n int numBlocksX = DIVUP(width, 2*numThreadsX);\n int numBlocksY = std::min(height, NUM_BLOCKS_MAX);\n\n dim3 grid(numBlocksX, numBlocksY), threads(numThreadsX, numThreadsY);\n assert(numBlocksX <= NUM_BLOCKS_MAX);\n assert(numBlocksY <= NUM_BLOCKS_MAX);\n\n if(width <= 64) {\n kAggRows<<>>(getDevData(), target.getDevData(),\n width, height, target.getLeadingDim(), agg, uop, bop);\n } else if(width <= 128) {\n kAggRows<<>>(getDevData(), target.getDevData(),\n width, height, target.getLeadingDim(), agg, uop, bop);\n } else if(width <= 256) {\n kAggRows<<>>(getDevData(), target.getDevData(),\n width, height, target.getLeadingDim(), agg, uop, bop);\n } else if(width <= 512) {\n kAggRows<<>>(getDevData(), target.getDevData(),\n width, height, target.getLeadingDim(), agg, uop, bop);\n } else {\n kAggRows<<>>(getDevData(), target.getDevData(),\n width, height, target.getLeadingDim(), agg, uop, bop);\n }\n\n getLastCudaError(\"agg rows: Kernel execution failed\");\n }\n }\n } else {\n target.applyBinary(NVMatrixBinaryOps::CompositeSecond(uop, bop), *this, target, stream);\n// copy(target, stream);\n }\n }\n}\n\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop) {\n _aggregate(axis, target, agg, uop, bop, getDefaultStream());\n}\n\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop) {\n _aggregate(axis, target, agg, NVMatrixOps::Identity(), bop, getDefaultStream());\n}\n\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop, cudaStream_t stream) {\n _aggregate(axis, target, agg, NVMatrixOps::Identity(), bop, stream);\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, UnaryOp uop, BinaryOp bop) {\n NVMatrix &sumVec = construct();\n _aggregate(axis, sumVec, agg, uop, bop);\n return sumVec;\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, UnaryOp uop, BinaryOp bop, cudaStream_t stream) {\n NVMatrix &sumVec = construct();\n _aggregate(axis, sumVec, agg, uop, bop, stream);\n return sumVec;\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, BinaryOp bop) {\n return _aggregate(axis, agg, NVMatrixOps::Identity(), bop);\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, BinaryOp bop, cudaStream_t stream) {\n return _aggregate(axis, agg, NVMatrixOps::Identity(), bop, stream);\n}\n\n\n\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, UnaryOp uop, BinaryOp bop, NVMatrix& tmp) {\n _aggregate(axis, target, agg, uop, bop, getDefaultStream(), tmp);\n}\n\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop, NVMatrix& tmp) {\n _aggregate(axis, target, agg, NVMatrixOps::Identity(), bop, getDefaultStream(), &tmp);\n}\n\ntemplate\nvoid NVMatrix::_aggregate(int axis, NVMatrix& target, Agg agg, BinaryOp bop, cudaStream_t stream, NVMatrix& tmp) {\n _aggregate(axis, target, agg, NVMatrixOps::Identity(), bop, stream, &tmp);\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, UnaryOp uop, BinaryOp bop, NVMatrix& tmp) {\n NVMatrix &sumVec = construct();\n _aggregate(axis, sumVec, agg, uop, bop, tmp);\n return sumVec;\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, UnaryOp uop, BinaryOp bop, cudaStream_t stream, NVMatrix& tmp) {\n NVMatrix &sumVec = construct();\n _aggregate(axis, sumVec, agg, uop, bop, stream, tmp);\n return sumVec;\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, BinaryOp bop, NVMatrix& tmp) {\n return _aggregate(axis, agg, NVMatrixOps::Identity(), bop, tmp);\n}\n\ntemplate\nNVMatrix& NVMatrix::_aggregate(int axis, Agg agg, BinaryOp bop, cudaStream_t stream, NVMatrix& tmp) {\n return _aggregate(axis, agg, NVMatrixOps::Identity(), bop, stream, tmp);\n}\n\nvoid NVMatrix::inRangeInc(float lower, float upper) {\n inRangeInc(lower, upper, *this);\n}\nvoid NVMatrix::inRangeInc(float lower, float upper, NVMatrix& target) {\n apply(NVMatrixOps::InRange(lower, upper), target);\n}\n\nvoid NVMatrix::inRangeExc(float lower, float upper) {\n inRangeExc(lower, upper, *this);\n}\n\nvoid NVMatrix::inRangeExc(float lower, float upper, NVMatrix& target) {\n apply(NVMatrixOps::InRange(lower, upper), target);\n}\n\nvoid NVMatrix::biggerThanScalar(float scalar) {\n biggerThanScalar(scalar, *this);\n}\n\nvoid NVMatrix::biggerThanScalar(float scalar, NVMatrix& target) {\n apply(NVMatrixOps::BiggerThanScalar(scalar), target);\n}\n\nvoid NVMatrix::smallerThanScalar(float scalar) {\n smallerThanScalar(scalar, *this);\n}\n\nvoid NVMatrix::smallerThanScalar(float scalar, NVMatrix& target) {\n apply(NVMatrixOps::SmallerThanScalar(scalar), target);\n}\n\nvoid NVMatrix::addScalar(float scaleThis, float scalar, NVMatrix& target) {\n apply(NVMatrixOps::WeightedAddScalar(scaleThis, scalar), target);\n}\n\nvoid NVMatrix::addScalar(float scalar, NVMatrix& target) {\n apply(NVMatrixOps::AddScalar(scalar), target);\n}\n\nvoid NVMatrix::addScalar(float scalar) {\n addScalar(scalar, *this);\n}\n\nvoid NVMatrix::minWithScalar(float scalar, NVMatrix& target) {\n apply(NVMatrixOps::MinWithScalar(scalar), target);\n}\n\nvoid NVMatrix::minWithScalar(float scalar) {\n minWithScalar(scalar, *this);\n}\n\nvoid NVMatrix::maxWithScalar(float scalar, NVMatrix& target) {\n apply(NVMatrixOps::MaxWithScalar(scalar), target);\n}\n\nvoid NVMatrix::maxWithScalar(float scalar) {\n maxWithScalar(scalar, *this);\n}\n\nvoid NVMatrix::pow(float p, NVMatrix& target) {\n apply(NVMatrixOps::Pow(p), target);\n}\n\nvoid NVMatrix::pow(float p) {\n pow(p, *this);\n}\n\nvoid NVMatrix::scale(float _scale) {\n scale(_scale, *this);\n}\n\nvoid NVMatrix::scale(float _scale, cudaStream_t stream) {\n scale(_scale, *this, stream);\n}\n\nvoid NVMatrix::scale(float _scale, NVMatrix& target) {\n scale(_scale, target, NVMatrix::getDefaultStream());\n}\n\nvoid NVMatrix::scale(float _scale, NVMatrix& target, cudaStream_t stream) {\n if (_scale != 1 || &target != this) { // optimize away scale by 1\n if (_scale == 1) {\n copy(target, stream);\n } else {\n apply(NVMatrixOps::MultByScalar(_scale), target, stream);\n }\n }\n}\n\nvoid NVMatrix::zero() {\n apply(NVMatrixOps::Zero());\n}\n\nvoid NVMatrix::zero(NVMatrix& like) {\n resize(like);\n zero();\n}\n\nvoid NVMatrix::max(int axis, NVMatrix& target) {\n _aggregate(axis, target, NVMatrixAggs::Max(), NVMatrixBinaryOps::Second());\n}\n\nvoid NVMatrix::max(int axis, NVMatrix& target, NVMatrix& tmp) {\n _aggregate(axis, target, NVMatrixAggs::Max(), NVMatrixBinaryOps::Second(), tmp);\n}\n\nvoid NVMatrix::addSum(NVMatrix& a, int axis, float scaleThis, float scaleSum) {\n addSum(a, axis, scaleThis, scaleSum, getDefaultStream());\n}\n\nvoid NVMatrix::addSum(NVMatrix& a, int axis, float scaleThis, float scaleSum, cudaStream_t stream) {\n if (scaleThis != 0) {\n a._aggregate(axis, *this, NVMatrixAggs::Sum(), NVMatrixBinaryOps::WeightedAdd(scaleThis, scaleSum), stream);\n } else {\n a._aggregate(axis, *this, NVMatrixAggs::Sum(), NVMatrixBinaryOps::SecondScaled(scaleSum), stream);\n }\n}\n\nvoid NVMatrix::addMax(NVMatrix& a, int axis, float scaleThis, float scaleMax) {\n addMax(a, axis, scaleThis, scaleMax, getDefaultStream());\n}\n\nvoid NVMatrix::addMax(NVMatrix& a, int axis, float scaleThis, float scaleMax, cudaStream_t stream) {\n if (scaleThis != 0) {\n a._aggregate(axis, *this, NVMatrixAggs::Max(), NVMatrixBinaryOps::WeightedAdd(scaleThis, scaleMax), stream);\n } else {\n a._aggregate(axis, *this, NVMatrixAggs::Max(), NVMatrixBinaryOps::SecondScaled(scaleMax), stream);\n }\n}\n\nvoid NVMatrix::sum(int axis, NVMatrix& target) {\n sum(axis, target, getDefaultStream());\n}\n\nvoid NVMatrix::sum(int axis, NVMatrix& target, cudaStream_t stream) {\n _aggregate(axis, target, NVMatrixAggs::Sum(), NVMatrixBinaryOps::Second(), stream);\n}\n\nvoid NVMatrix::sum(int axis, NVMatrix& target, NVMatrix& tmp) {\n sum(axis, target, getDefaultStream(), tmp);\n}\n\nvoid NVMatrix::sum(int axis, NVMatrix& target, cudaStream_t stream, NVMatrix& tmp) {\n _aggregate(axis, target, NVMatrixAggs::Sum(), NVMatrixBinaryOps::Second(), stream, tmp);\n}\n\nvoid NVMatrix::sumOfSquares(int axis, NVMatrix& target) {\n sumOfSquares(axis, target, getDefaultStream());\n}\n\nvoid NVMatrix::sumOfSquares(int axis, NVMatrix& target, cudaStream_t stream) {\n _aggregate(axis, target, NVMatrixAggs::Sum(), NVMatrixOps::Square(), NVMatrixBinaryOps::Second(), stream);\n}\n\nvoid NVMatrix::min(int axis, NVMatrix& target) {\n _aggregate(axis, target, NVMatrixAggs::Min(), NVMatrixBinaryOps::Second());\n}\n\nNVMatrix& NVMatrix::max(int axis) {\n return _aggregate(axis, NVMatrixAggs::Max(), NVMatrixBinaryOps::Second());\n}\n\nNVMatrix& NVMatrix::sum(int axis) {\n return _aggregate(axis, NVMatrixAggs::Sum(), NVMatrixBinaryOps::Second());\n}\n\nNVMatrix& NVMatrix::min(int axis) {\n return _aggregate(axis, NVMatrixAggs::Min(), NVMatrixBinaryOps::Second());\n}\n\nNVMatrix& NVMatrix::sumOfSquares(int axis) {\n return _aggregate(axis, NVMatrixAggs::Sum(), NVMatrixOps::Square(), NVMatrixBinaryOps::Second());\n}\n\nvoid NVMatrix::_sum_setParams(int n, dim3* blocks, dim3* threads) {\n *threads = dim3(DP_BLOCKSIZE);\n *blocks = dim3(std::min(CPUSUM_MAX, DIVUP(n, DP_BLOCKSIZE)));\n}\n\nfloat NVMatrix::mean() {\n return sum() / getNumElements();\n}\n\nfloat NVMatrix::sum() {\n return _totalAgg(NVMatrixAggs::Sum());\n}\n\nfloat NVMatrix::sum(NVMatrix& tmpbuf) {\n return _totalAgg(NVMatrixAggs::Sum(), tmpbuf, getDefaultStream());\n}\n\nfloat NVMatrix::max() {\n return _totalAgg(NVMatrixAggs::Max());\n}\n\nfloat NVMatrix::min() {\n return _totalAgg(NVMatrixAggs::Min());\n}\n\nfloat NVMatrix::countNan() {\n return _totalAgg(NVMatrixAggs::CountNan());\n}\n\nfloat NVMatrix::countInf() {\n return _totalAgg(NVMatrixAggs::CountInf());\n}\n\ntemplate\nfloat NVMatrix::_totalAgg(Agg agg) {\n return _totalAgg(agg, getDefaultStream());\n}\n\ntemplate\nfloat NVMatrix::_totalAgg(Agg agg, cudaStream_t stream) {\n NVMatrix tmp;\n return _totalAgg(agg, tmp, stream);\n}\n\ntemplate\nfloat NVMatrix::_totalAgg(Agg agg, NVMatrix& tmpbuf, cudaStream_t stream) {\n assert(isContiguous());\n dim3 blocks, threads;\n // Sum most of it on GPU\n\n _sum_setParams(getNumElements(), &blocks, &threads);\n tmpbuf.resize(1, blocks.x);\n kTotalAgg<<>>(getDevData(), tmpbuf.getDevData(), getNumElements(), agg);\n getLastCudaError(\"kTotalAgg: Kernel execution failed\");\n // Don't need to sync because we copyToHost in the same stream, so it's serialized\n// NVMatrix::syncStream(stream);\n return tmpbuf.cpuAgg(agg, stream);\n}\ntemplate\nfloat NVMatrix::cpuAgg(Agg agg, cudaStream_t stream) {\n Matrix bufCPU(getNumRows(), getNumCols());\n copyToHost(bufCPU, false, stream);\n if (getNumElements() > 1) { // Sum remainder on CPU\n if (typeid(Agg) == typeid(NVMatrixAggs::Sum)) {\n return bufCPU.sum();\n } else if (typeid(Agg) == typeid(NVMatrixAggs::Max)) {\n return bufCPU.max();\n } else if (typeid(Agg) == typeid(NVMatrixAggs::Min)) {\n return bufCPU.min();\n } else if (typeid(Agg) == typeid(NVMatrixAggs::CountNan)) {\n return bufCPU.hasNan(); //yea, it's not the same, who cares\n } else if (typeid(Agg) == typeid(NVMatrixAggs::CountInf)) {\n return bufCPU.hasInf();\n } else {\n assert(false);\n }\n }\n return bufCPU(0,0);\n}\n\nfloat NVMatrix::dotProduct(NVMatrix& b) {\n return dotProduct(b, getDefaultStream());\n}\n\nfloat NVMatrix::dotProduct(NVMatrix& b, cudaStream_t stream) {\n NVMatrix tmp;\n return dotProduct(b, tmp, stream);\n}\n\n/*\n * Fast dot product only for matrices with same transposedness.\n */\nfloat NVMatrix::dotProduct(NVMatrix& b, NVMatrix& tmp, cudaStream_t stream) {\n assert(isContiguous() && b.isContiguous());\n assert(isSameDims(b));\n assert(isTrans() == b.isTrans()); // see?\n dim3 blocks, threads;\n _sum_setParams(getNumElements(), &blocks, &threads);\n// NVMatrix target(1, blocks.x);\n tmp.resize(1, blocks.x);\n kDotProduct_r<<>>(getDevData(), b.getDevData(), tmp.getDevData(), getNumElements());\n getLastCudaError(\"kDotProduct_r: Kernel execution failed\");\n// cudaThreadSynchronize();\n// syncStream(stream);\n// return tmp._totalAgg(NVMatrixAggs::Sum(), stream);\n return tmp.cpuAgg(NVMatrixAggs::Sum(), stream);\n}\n\nfloat NVMatrix::norm2() {\n return dotProduct(*this);\n}\n\nfloat NVMatrix::norm() {\n return sqrt(norm2());\n}\n\nvoid NVMatrix::print(int startRow, int rows, int startCol, int cols) const {\n// cudaThreadSynchronize();\n syncDevice();\n Matrix hm = Matrix(_numRows, _numCols);\n copyToHost(hm);\n hm.print(startRow, rows, startCol, cols);\n}\n\nvoid NVMatrix::print(int rows, int cols) const {\n print(0, rows, 0, cols);\n}\n\nvoid NVMatrix::printShape(const char* name) const {\n printf(\"%s: %dx%d\\n\", name, _numRows, _numCols);\n}\n\nvoid NVMatrix::alloc(int numElements) {\n _memSegment = DEVICE_MEMORY_MANAGER::getInstance(getDeviceID()).malloc(numElements * sizeof(float));\n}\n\nvoid NVMatrix::dealloc() {\n DEVICE_MEMORY_MANAGER::getInstance(_memSegment->getDeviceID()).free(_memSegment);\n _memSegment = NULL;\n deallocTexture();\n}\n\nvoid NVMatrix::deallocTexture() {\n if (_texObj != 0) {\n checkCudaErrors(cudaDestroyTextureObject(_texObj));\n _texObj = 0;\n }\n}\n\ncudaTextureObject_t NVMatrix::getTextureObject() {\n if (_texObj == 0) {\n assert(isContiguous());\n //size_t memFree, memTotal;\n\n struct cudaResourceDesc resDesc;\n memset(&resDesc, 0, sizeof(resDesc));\n resDesc.resType = cudaResourceTypeLinear;\n resDesc.res.linear.devPtr = getDevData();\n resDesc.res.linear.sizeInBytes = getNumDataBytes();\n resDesc.res.linear.desc = cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);\n struct cudaTextureDesc texDesc;\n memset(&texDesc, 0, sizeof(texDesc));\n checkCudaErrors(cudaCreateTextureObject(&_texObj, &resDesc, &texDesc, NULL));\n }\n assert(_texObj != 0);\n return _texObj;\n}\n\nNVMatrix& NVMatrix::construct() const {\n return *new NVMatrix();\n}\nNVMatrix& NVMatrix::construct(bool isTrans) const {\n return *new NVMatrix(isTrans);\n}\nNVMatrix& NVMatrix::construct(int numRows, int numCols, bool isTrans) const {\n return *new NVMatrix(numRows, numCols, isTrans);\n}\nNVMatrix& NVMatrix::construct(const Matrix& like, bool copy) const {\n return *new NVMatrix(like, copy);\n}\nNVMatrix& NVMatrix::construct(const NVMatrix& like, bool copy) const {\n return *new NVMatrix(like, copy);\n}\nNVMatrix& NVMatrix::construct(const NVMatrix& like) const {\n return *new NVMatrix(like);\n}\nNVMatrix& NVMatrix::construct(const Matrix& like) const {\n return *new NVMatrix(like);\n}\nNVMatrix& NVMatrix::construct(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans) const {\n return *new NVMatrix(mem, numRows, numCols, stride, isTrans);\n}\n\nstd::pair NVMatrix::getCudaMemorySize() {\n size_t memFree, memTotal;\n checkCudaErrors(cudaMemGetInfo(&memFree, &memTotal));\n return std::pair(memFree, memTotal);\n}\n\n\n/* ================\n * HostNVMatrix\n * ================\n */\nHostNVMatrix::~HostNVMatrix() {\n if (_ownsData && _numElements > 0) {\n dealloc();\n } else {\n // dealloc frees the mem segment. But if this is a view,\n // then we need to delete the mem segment object.\n// assert(_memSegment == NULL || _memSegment->getSize() == 0);\n delete _memSegment;\n }\n _deleted = true;\n}\nHostNVMatrix::HostNVMatrix() : NVMatrix() {\n _init(false);\n}\nHostNVMatrix::HostNVMatrix(bool isTrans) {\n _init(isTrans);\n}\nHostNVMatrix::HostNVMatrix(int numRows, int numCols, bool isTrans) {\n _init(isTrans);\n resize(numRows, numCols);\n}\nHostNVMatrix::HostNVMatrix(const Matrix& like, bool copy) {\n _init(like.isTrans());\n resize(like.getNumRows(), like.getNumCols());\n if (copy) {\n copyFromHost(like);\n }\n}\nHostNVMatrix::HostNVMatrix(const NVMatrix& like, bool copy) {\n _init(like.isTrans());\n resize(like.getNumRows(), like.getNumCols());\n if (copy) {\n like.copy(*this);\n }\n}\nHostNVMatrix::HostNVMatrix(const NVMatrix& like) {\n _init(like.isTrans());\n resize(like.getNumRows(), like.getNumCols());\n}\nHostNVMatrix::HostNVMatrix(const Matrix& like) {\n _init(false);\n resize(like.getNumRows(), like.getNumCols());\n}\nHostNVMatrix::HostNVMatrix(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans)\n : NVMatrix(mem, numRows, numCols, stride, isTrans) {\n}\n\nNVMatrix& HostNVMatrix::construct() const {\n return *new HostNVMatrix();\n}\nNVMatrix& HostNVMatrix::construct(bool isTrans) const {\n return *new HostNVMatrix(isTrans);\n}\nNVMatrix& HostNVMatrix::construct(int numRows, int numCols, bool isTrans) const {\n return *new HostNVMatrix(numRows, numCols, isTrans);\n}\nNVMatrix& HostNVMatrix::construct(const Matrix& like, bool copy) const {\n return *new HostNVMatrix(like, copy);\n}\nNVMatrix& HostNVMatrix::construct(const NVMatrix& like, bool copy) const {\n return *new HostNVMatrix(like, copy);\n}\nNVMatrix& HostNVMatrix::construct(const NVMatrix& like) const {\n return *new HostNVMatrix(like);\n}\nNVMatrix& HostNVMatrix::construct(const Matrix& like) const {\n return *new HostNVMatrix(like);\n}\nNVMatrix& HostNVMatrix::construct(MemorySegment* mem, int numRows, int numCols, int stride, bool isTrans) const {\n return *new HostNVMatrix(mem, numRows, numCols, stride, isTrans);\n}\n\nvoid HostNVMatrix::copyFromHost(const Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream) {\n if (resizeTarget) {\n resize(hostMatrix);\n } else {\n assert(isSameDims(hostMatrix));\n }\n setTrans(hostMatrix.isTrans());\n if (getNumElements() > 0) {\n checkCudaErrors(cudaMemcpy2D(getDevData(), _stride * sizeof(float), hostMatrix.getData(),\n hostMatrix.getLeadingDim() * sizeof(float), getLeadingDim() * sizeof(float),\n getFollowingDim(), cudaMemcpyHostToHost));\n// syncStream(stream);\n }\n}\n\nvoid HostNVMatrix::copyFromHost(const Matrix& hostMatrix, bool resizeTarget) {\n copyFromHost(hostMatrix, resizeTarget, 0);\n}\n\nvoid HostNVMatrix::copyFromHost(const Matrix& hostMatrix) {\n copyFromHost(hostMatrix, false, 0);\n}\n\nvoid HostNVMatrix::copyToHost(Matrix& hostMatrix, bool resizeTarget, cudaStream_t stream) const {\n if (resizeTarget) {\n hostMatrix.resize(getNumRows(), getNumCols());\n } else {\n assert(isSameDims(hostMatrix));\n }\n hostMatrix.setTrans(_isTrans);\n if (getNumElements() > 0) {\n checkCudaErrors(cudaMemcpy2D(hostMatrix.getData(), hostMatrix.getLeadingDim() * sizeof(float),\n getDevData(), _stride * sizeof(float), getLeadingDim() * sizeof(float),\n getFollowingDim(), cudaMemcpyHostToHost));\n// syncStream(stream);\n }\n}\n\nvoid HostNVMatrix::copyToHost(Matrix& hostMatrix, bool resizeTarget) const {\n copyToHost(hostMatrix, resizeTarget, 0);\n}\n\nvoid HostNVMatrix::copyToHost(Matrix& hostMatrix) const {\n copyToHost(hostMatrix, false, 0);\n}\n\nvoid HostNVMatrix::alloc(int numElements) {\n// checkCudaErrors(cudaHostAlloc(&_devData, numElements * sizeof(float), cudaHostAllocPortable));\n _memSegment = HOST_MEMORY_MANAGER::getInstance().malloc(numElements * sizeof(float));\n// _memSegment = FastHostMemoryManager::getInstance().malloc(numElements * sizeof(float));\n}\n\nvoid HostNVMatrix::dealloc() {\n// FastHostMemoryManager::getInstance().free(_memSegment);\n HOST_MEMORY_MANAGER::getInstance().free(_memSegment);\n _memSegment = NULL;\n// checkCudaErrors(cudaFreeHost(_devData));\n}\n\ncudaTextureObject_t HostNVMatrix::getTextureObject() {\n assert(false);\n return 0;\n}\n" }, { "path": "caffe2/contrib/cuda-convnet2/nvmatrix/src/nvmatrix_kernels.cu", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n#include \"../include/nvmatrix_kernels.cuh\"\n\n__global__ void kTile(const float* src, float* tgt, const uint srcWidth, const uint srcHeight, const uint tgtWidth, const uint tgtHeight) {\n const int idx = blockIdx.x * blockDim.x + threadIdx.x;\n const int numThreads = blockDim.x * gridDim.x;\n // const unsigned int numEls = tgtWidth * tgtHeight;\n for (uint i = idx; i < tgtWidth * tgtHeight; i += numThreads) {\n const uint y = i / tgtWidth;\n const uint x = i % tgtWidth;\n const uint srcY = y % srcHeight;\n const uint srcX = x % srcWidth;\n tgt[i] = src[srcY * srcWidth + srcX];\n }\n}\n\n__global__ void kDotProduct_r(float* a, float* b, float* target, const uint numElements) {\n __shared__ float shmem[DP_BLOCKSIZE];\n\n uint eidx = DP_BLOCKSIZE * blockIdx.x + threadIdx.x;\n shmem[threadIdx.x] = 0;\n if (eidx < gridDim.x * DP_BLOCKSIZE) {\n for (; eidx < numElements; eidx += gridDim.x * DP_BLOCKSIZE) {\n shmem[threadIdx.x] += a[eidx] * b[eidx];\n }\n }\n __syncthreads();\n if (threadIdx.x < 256) {\n shmem[threadIdx.x] += shmem[threadIdx.x + 256];\n }\n __syncthreads();\n if (threadIdx.x < 128) {\n shmem[threadIdx.x] += shmem[threadIdx.x + 128];\n }\n __syncthreads();\n if (threadIdx.x < 64) {\n shmem[threadIdx.x] += shmem[threadIdx.x + 64];\n }\n __syncthreads();\n if (threadIdx.x < 32) {\n volatile float* mysh = &shmem[threadIdx.x];\n *mysh += mysh[32];\n *mysh += mysh[16];\n *mysh += mysh[8];\n *mysh += mysh[4];\n *mysh += mysh[2];\n *mysh += mysh[1];\n if (threadIdx.x == 0) {\n target[blockIdx.x] = *mysh;\n }\n }\n}\n\n__global__ void kSetupCurand(curandState *state, unsigned long long seed) {\n const uint tidx = NUM_RND_THREADS_PER_BLOCK * blockIdx.x + threadIdx.x;\n /* Each thread gets same seed, a different sequence number,\n no offset */\n curand_init(seed, tidx, 0, &state[tidx]);\n}\n\n" }, { "path": "caffe2/contrib/cuda-convnet2/python_util/__init__.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License." }, { "path": "caffe2/contrib/cuda-convnet2/python_util/data.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport numpy as n\nfrom numpy.random import randn, rand, random_integers\nimport os\nfrom threading import Thread\nfrom util import *\n\nBATCH_META_FILE = \"batches.meta\"\n\nclass DataLoaderThread(Thread):\n def __init__(self, path, tgt):\n Thread.__init__(self)\n self.path = path\n self.tgt = tgt\n def run(self):\n self.tgt += [unpickle(self.path)]\n \nclass DataProvider:\n BATCH_REGEX = re.compile('^data_batch_(\\d+)(\\.\\d+)?$')\n def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batchnum=None, dp_params={}, test=False):\n if batch_range == None:\n batch_range = DataProvider.get_batch_nums(data_dir)\n if init_batchnum is None or init_batchnum not in batch_range:\n init_batchnum = batch_range[0]\n\n self.data_dir = data_dir\n self.batch_range = batch_range\n self.curr_epoch = init_epoch\n self.curr_batchnum = init_batchnum\n self.dp_params = dp_params\n self.batch_meta = self.get_batch_meta(data_dir)\n self.data_dic = None\n self.test = test\n self.batch_idx = batch_range.index(init_batchnum)\n\n def get_next_batch(self):\n if self.data_dic is None or len(self.batch_range) > 1:\n self.data_dic = self.get_batch(self.curr_batchnum)\n epoch, batchnum = self.curr_epoch, self.curr_batchnum\n self.advance_batch()\n\n return epoch, batchnum, self.data_dic\n \n def get_batch(self, batch_num):\n fname = self.get_data_file_name(batch_num)\n if os.path.isdir(fname): # batch in sub-batches\n sub_batches = sorted(os.listdir(fname), key=alphanum_key)\n #print sub_batches\n num_sub_batches = len(sub_batches)\n tgts = [[] for i in xrange(num_sub_batches)]\n threads = [DataLoaderThread(os.path.join(fname, s), tgt) for (s, tgt) in zip(sub_batches, tgts)]\n for thread in threads:\n thread.start()\n for thread in threads:\n thread.join()\n \n return [t[0] for t in tgts]\n return unpickle(self.get_data_file_name(batch_num))\n \n def get_data_dims(self,idx=0):\n return self.batch_meta['num_vis'] if idx == 0 else 1\n \n def advance_batch(self):\n self.batch_idx = self.get_next_batch_idx()\n self.curr_batchnum = self.batch_range[self.batch_idx]\n if self.batch_idx == 0: # we wrapped\n self.curr_epoch += 1\n \n def get_next_batch_idx(self):\n return (self.batch_idx + 1) % len(self.batch_range)\n \n def get_next_batch_num(self):\n return self.batch_range[self.get_next_batch_idx()]\n \n # get filename of current batch\n def get_data_file_name(self, batchnum=None):\n if batchnum is None:\n batchnum = self.curr_batchnum\n return os.path.join(self.data_dir, 'data_batch_%d' % batchnum)\n \n @classmethod\n def get_instance(cls, data_dir, batch_range=None, init_epoch=1, init_batchnum=None, type=\"default\", dp_params={}, test=False):\n # why the fuck can't i reference DataProvider in the original definition?\n #cls.dp_classes['default'] = DataProvider\n type = type or DataProvider.get_batch_meta(data_dir)['dp_type'] # allow data to decide data provider\n if type.startswith(\"dummy-\"):\n name = \"-\".join(type.split('-')[:-1]) + \"-n\"\n if name not in dp_types:\n raise DataProviderException(\"No such data provider: %s\" % type)\n _class = dp_classes[name]\n dims = int(type.split('-')[-1])\n return _class(dims)\n elif type in dp_types:\n _class = dp_classes[type]\n return _class(data_dir, batch_range, init_epoch, init_batchnum, dp_params, test)\n \n raise DataProviderException(\"No such data provider: %s\" % type)\n \n @classmethod\n def register_data_provider(cls, name, desc, _class):\n if name in dp_types:\n raise DataProviderException(\"Data provider %s already registered\" % name)\n dp_types[name] = desc\n dp_classes[name] = _class\n \n @staticmethod\n def get_batch_meta(data_dir):\n return unpickle(os.path.join(data_dir, BATCH_META_FILE))\n \n @staticmethod\n def get_batch_filenames(srcdir):\n return sorted([f for f in os.listdir(srcdir) if DataProvider.BATCH_REGEX.match(f)], key=alphanum_key)\n \n @staticmethod\n def get_batch_nums(srcdir):\n names = DataProvider.get_batch_filenames(srcdir)\n return sorted(list(set(int(DataProvider.BATCH_REGEX.match(n).group(1)) for n in names)))\n \n @staticmethod\n def get_num_batches(srcdir):\n return len(DataProvider.get_batch_nums(srcdir))\n \nclass DummyDataProvider(DataProvider):\n def __init__(self, data_dim):\n #self.data_dim = data_dim\n self.batch_range = [1]\n self.batch_meta = {'num_vis': data_dim, 'data_in_rows':True}\n self.curr_epoch = 1\n self.curr_batchnum = 1\n self.batch_idx = 0\n \n def get_next_batch(self):\n epoch, batchnum = self.curr_epoch, self.curr_batchnum\n self.advance_batch()\n data = rand(512, self.get_data_dims()).astype(n.single)\n return self.curr_epoch, self.curr_batchnum, {'data':data}\n\nclass LabeledDataProvider(DataProvider): \n def __init__(self, data_dir, batch_range=None, init_epoch=1, init_batchnum=None, dp_params={}, test=False):\n DataProvider.__init__(self, data_dir, batch_range, init_epoch, init_batchnum, dp_params, test)\n \n def get_num_classes(self):\n return len(self.batch_meta['label_names'])\n \nclass LabeledDummyDataProvider(DummyDataProvider):\n def __init__(self, data_dim, num_classes=10, num_cases=7):\n #self.data_dim = data_dim\n self.batch_range = [1]\n self.batch_meta = {'num_vis': data_dim,\n 'label_names': [str(x) for x in range(num_classes)],\n 'data_in_rows':True}\n self.num_cases = num_cases\n self.num_classes = num_classes\n self.curr_epoch = 1\n self.curr_batchnum = 1\n self.batch_idx=0\n self.data = None\n \n def get_num_classes(self):\n return self.num_classes\n \n def get_next_batch(self):\n epoch, batchnum = self.curr_epoch, self.curr_batchnum\n self.advance_batch()\n if self.data is None:\n data = rand(self.num_cases, self.get_data_dims()).astype(n.single) # <--changed to rand\n labels = n.require(n.c_[random_integers(0,self.num_classes-1,self.num_cases)], requirements='C', dtype=n.single)\n self.data, self.labels = data, labels\n else:\n data, labels = self.data, self.labels\n# print data.shape, labels.shape\n return self.curr_epoch, self.curr_batchnum, [data.T, labels.T ]\n\n \ndp_types = {\"dummy-n\": \"Dummy data provider for n-dimensional data\",\n \"dummy-labeled-n\": \"Labeled dummy data provider for n-dimensional data\"}\ndp_classes = {\"dummy-n\": DummyDataProvider,\n \"dummy-labeled-n\": LabeledDummyDataProvider}\n \nclass DataProviderException(Exception):\n pass\n" }, { "path": "caffe2/contrib/cuda-convnet2/python_util/gpumodel.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport numpy as n\nimport os\nfrom time import time, asctime, localtime, strftime\nfrom util import *\nfrom data import *\nfrom options import *\nfrom math import ceil, floor, sqrt\nfrom data import DataProvider, dp_types\nimport sys\nimport shutil\nimport platform\nfrom os import linesep as NL\nfrom threading import Thread\nimport tempfile as tf\n\nclass ModelStateException(Exception):\n pass\n\nclass CheckpointWriter(Thread):\n def __init__(self, path, dic):\n Thread.__init__(self)\n self.path = path\n self.dic = dic\n \n def run(self):\n save_dir = os.path.dirname(self.path)\n save_file = os.path.basename(self.path)\n # Write checkpoint to temporary filename\n tmpfile = tf.NamedTemporaryFile(dir=os.path.dirname(save_dir), delete=False)\n pickle(tmpfile, self.dic) # Also closes tf\n # Move it to final filename\n os.rename(tmpfile.name, self.path)\n # Delete old checkpoints\n for f in os.listdir(save_dir):\n if f != save_file:\n os.remove(os.path.join(save_dir, f))\n\n# GPU Model interface\nclass IGPUModel:\n def __init__(self, model_name, op, load_dic, filename_options=[], dp_params={}):\n # these are input parameters\n self.model_name = model_name\n self.op = op\n self.options = op.options\n self.load_dic = load_dic\n self.filename_options = filename_options\n self.dp_params = dp_params\n self.device_ids = self.op.get_value('gpu')\n self.fill_excused_options()\n self.checkpoint_writer = None\n #assert self.op.all_values_given()\n \n for o in op.get_options_list():\n setattr(self, o.name, o.value)\n self.loaded_from_checkpoint = load_dic is not None\n # these are things that the model must remember but they're not input parameters\n if self.loaded_from_checkpoint:\n self.model_state = load_dic[\"model_state\"]\n self.save_file = self.options[\"save_file_override\"].value if self.options[\"save_file_override\"].value_given else self.options['load_file'].value\n if not os.path.isdir(self.save_file) and os.path.exists(self.save_file):\n self.save_file = os.path.dirname(self.save_file)\n# print self.options[\"save_file_override\"].value, self.save_file\n else:\n self.model_state = {}\n self.save_file = self.options[\"save_file_override\"].value if self.options[\"save_file_override\"].value_given else os.path.join(self.options['save_path'].value, model_name + \"_\" + '_'.join(['%s_%s' % (char, self.options[opt].get_str_value()) for opt, char in filename_options]) + '_' + strftime('%Y-%m-%d_%H.%M.%S'))\n self.model_state[\"train_outputs\"] = []\n self.model_state[\"test_outputs\"] = []\n self.model_state[\"epoch\"] = 1\n self.model_state[\"batchnum\"] = self.train_batch_range[0]\n# print self.save_file\n\n self.init_data_providers()\n if load_dic: \n self.train_data_provider.advance_batch()\n \n # model state often requries knowledge of data provider, so it's initialized after\n try:\n self.init_model_state()\n except ModelStateException, e:\n print e\n sys.exit(1)\n for var, val in self.model_state.iteritems():\n setattr(self, var, val)\n \n self.import_model()\n self.init_model_lib()\n\n def import_model(self):\n print \"=========================\"\n print \"Importing %s C++ module\" % ('_' + self.model_name)\n self.libmodel = __import__('_' + self.model_name) \n \n def fill_excused_options(self):\n pass\n \n def init_data_providers(self):\n self.dp_params['convnet'] = self\n try:\n self.test_data_provider = DataProvider.get_instance(self.data_path, self.test_batch_range,\n type=self.dp_type, dp_params=self.dp_params, test=True)\n self.train_data_provider = DataProvider.get_instance(self.data_path, self.train_batch_range,\n self.model_state[\"epoch\"], self.model_state[\"batchnum\"],\n type=self.dp_type, dp_params=self.dp_params, test=False)\n except DataProviderException, e:\n print \"Unable to create data provider: %s\" % e\n self.print_data_providers()\n sys.exit()\n \n def init_model_state(self):\n pass\n \n def init_model_lib(self):\n pass\n \n def start(self):\n if self.test_only:\n self.test_outputs += [self.get_test_error()]\n self.print_test_results()\n else:\n self.train()\n self.cleanup()\n if self.force_save:\n self.save_state().join()\n sys.exit(0)\n \n def train(self):\n print \"=========================\"\n print \"Training %s\" % self.model_name\n self.op.print_values()\n print \"=========================\"\n self.print_model_state()\n print \"Running on CUDA device(s) %s\" % \", \".join(\"%d\" % d for d in self.device_ids)\n print \"Current time: %s\" % asctime(localtime())\n print \"Saving checkpoints to %s\" % self.save_file\n print \"=========================\"\n next_data = self.get_next_batch()\n while self.epoch <= self.num_epochs:\n data = next_data\n self.epoch, self.batchnum = data[0], data[1]\n self.print_iteration()\n sys.stdout.flush()\n \n compute_time_py = time()\n self.start_batch(data)\n \n # load the next batch while the current one is computing\n next_data = self.get_next_batch()\n \n batch_output = self.finish_batch()\n self.train_outputs += [batch_output]\n self.print_train_results()\n\n if self.get_num_batches_done() % self.testing_freq == 0:\n self.sync_with_host()\n self.test_outputs += [self.get_test_error()]\n self.print_test_results()\n self.print_test_status()\n self.conditional_save()\n \n self.print_elapsed_time(time() - compute_time_py)\n \n def cleanup(self):\n if self.checkpoint_writer is not None:\n self.checkpoint_writer.join()\n self.checkpoint_writer = None\n \n def print_model_state(self):\n pass\n \n def get_num_batches_done(self):\n return len(self.train_batch_range) * (self.epoch - 1) + self.batchnum - self.train_batch_range[0] + 1\n \n def get_next_batch(self, train=True):\n dp = self.train_data_provider\n if not train:\n dp = self.test_data_provider\n return self.parse_batch_data(dp.get_next_batch(), train=train)\n \n def parse_batch_data(self, batch_data, train=True):\n return batch_data[0], batch_data[1], batch_data[2]['data']\n \n def start_batch(self, batch_data, train=True):\n self.libmodel.startBatch(batch_data[2], not train)\n \n def finish_batch(self):\n return self.libmodel.finishBatch()\n \n def print_iteration(self):\n print \"\\t%d.%d...\" % (self.epoch, self.batchnum),\n \n def print_elapsed_time(self, compute_time_py):\n print \"(%.3f sec)\" % (compute_time_py)\n \n def print_train_results(self):\n batch_error = self.train_outputs[-1][0]\n if not (batch_error > 0 and batch_error < 2e20):\n print \"Crazy train error: %.6f\" % batch_error\n self.cleanup()\n\n print \"Train error: %.6f \" % (batch_error),\n\n def print_test_results(self):\n batch_error = self.test_outputs[-1][0]\n print \"%s\\t\\tTest error: %.6f\" % (NL, batch_error),\n\n def print_test_status(self):\n status = (len(self.test_outputs) == 1 or self.test_outputs[-1][0] < self.test_outputs[-2][0]) and \"ok\" or \"WORSE\"\n print status,\n \n def sync_with_host(self):\n if self.checkpoint_writer is not None:\n self.checkpoint_writer.join()\n self.checkpoint_writer = None\n self.libmodel.syncWithHost()\n \n def conditional_save(self):\n batch_error = self.test_outputs[-1][0]\n if batch_error > 0 and batch_error < self.max_test_err:\n self.save_state()\n else:\n print \"\\tTest error > %g, not saving.\" % self.max_test_err,\n \n def aggregate_test_outputs(self, test_outputs):\n test_error = tuple([sum(t[r] for t in test_outputs) / (1 if self.test_one else len(self.test_batch_range)) for r in range(len(test_outputs[-1]))])\n return test_error\n \n def get_test_error(self):\n next_data = self.get_next_batch(train=False)\n test_outputs = []\n while True:\n data = next_data\n start_time_test = time()\n self.start_batch(data, train=False)\n load_next = (not self.test_one or self.test_only) and data[1] < self.test_batch_range[-1]\n if load_next: # load next batch\n next_data = self.get_next_batch(train=False)\n test_outputs += [self.finish_batch()]\n if self.test_only: # Print the individual batch results for safety\n print \"batch %d: %s\" % (data[1], str(test_outputs[-1])),\n self.print_elapsed_time(time() - start_time_test)\n if not load_next:\n break\n sys.stdout.flush()\n \n return self.aggregate_test_outputs(test_outputs)\n \n def set_var(self, var_name, var_val):\n setattr(self, var_name, var_val)\n self.model_state[var_name] = var_val\n return var_val\n \n def get_var(self, var_name):\n return self.model_state[var_name]\n \n def has_var(self, var_name):\n return var_name in self.model_state\n \n def save_state(self):\n for att in self.model_state:\n if hasattr(self, att):\n self.model_state[att] = getattr(self, att)\n \n dic = {\"model_state\": self.model_state,\n \"op\": self.op}\n \n checkpoint_file = \"%d.%d\" % (self.epoch, self.batchnum)\n checkpoint_file_full_path = os.path.join(self.save_file, checkpoint_file)\n if not os.path.exists(self.save_file):\n os.makedirs(self.save_file)\n \n assert self.checkpoint_writer is None\n self.checkpoint_writer = CheckpointWriter(checkpoint_file_full_path, dic)\n self.checkpoint_writer.start()\n print \"-------------------------------------------------------\"\n print \"Saved checkpoint to %s\" % self.save_file\n print \"=======================================================\",\n return self.checkpoint_writer\n \n def get_progress(self):\n num_batches_total = self.num_epochs * len(self.train_batch_range)\n return min(1.0, max(0.0, float(self.get_num_batches_done()-1) / num_batches_total))\n \n @staticmethod\n def load_checkpoint(load_dir):\n if os.path.isdir(load_dir):\n return unpickle(os.path.join(load_dir, sorted(os.listdir(load_dir), key=alphanum_key)[-1]))\n return unpickle(load_dir)\n\n @staticmethod\n def get_options_parser():\n op = OptionsParser()\n op.add_option(\"load-file\", \"load_file\", StringOptionParser, \"Load file\", default=\"\", excuses=OptionsParser.EXCUSE_ALL)\n op.add_option(\"save-path\", \"save_path\", StringOptionParser, \"Save path\", excuses=['save_file_override'])\n op.add_option(\"save-file\", \"save_file_override\", StringOptionParser, \"Save file override\", excuses=['save_path'])\n op.add_option(\"train-range\", \"train_batch_range\", RangeOptionParser, \"Data batch range: training\")\n op.add_option(\"test-range\", \"test_batch_range\", RangeOptionParser, \"Data batch range: testing\")\n op.add_option(\"data-provider\", \"dp_type\", StringOptionParser, \"Data provider\", default=\"default\")\n op.add_option(\"test-freq\", \"testing_freq\", IntegerOptionParser, \"Testing frequency\", default=25)\n op.add_option(\"epochs\", \"num_epochs\", IntegerOptionParser, \"Number of epochs\", default=500)\n op.add_option(\"data-path\", \"data_path\", StringOptionParser, \"Data path\")\n \n op.add_option(\"max-test-err\", \"max_test_err\", FloatOptionParser, \"Maximum test error for saving\")\n op.add_option(\"test-only\", \"test_only\", BooleanOptionParser, \"Test and quit?\", default=0)\n op.add_option(\"test-one\", \"test_one\", BooleanOptionParser, \"Test on one batch at a time?\", default=1)\n op.add_option(\"force-save\", \"force_save\", BooleanOptionParser, \"Force save before quitting\", default=0)\n op.add_option(\"gpu\", \"gpu\", ListOptionParser(IntegerOptionParser), \"GPU override\")\n return op\n\n @staticmethod\n def print_data_providers():\n print \"Available data providers:\"\n for dp, desc in dp_types.iteritems():\n print \" %s: %s\" % (dp, desc)\n \n\n @staticmethod\n def parse_options(op):\n try:\n load_dic = None\n options = op.parse()\n load_location = None\n# print options['load_file'].value_given, options['save_file_override'].value_given\n# print options['save_file_override'].value\n if options['load_file'].value_given:\n load_location = options['load_file'].value\n elif options['save_file_override'].value_given and os.path.exists(options['save_file_override'].value):\n load_location = options['save_file_override'].value\n \n if load_location is not None:\n load_dic = IGPUModel.load_checkpoint(load_location)\n old_op = load_dic[\"op\"]\n old_op.merge_from(op)\n op = old_op\n op.eval_expr_defaults()\n return op, load_dic\n except OptionMissingException, e:\n print e\n op.print_usage()\n except OptionException, e:\n print e\n except UnpickleError, e:\n print \"Error loading checkpoint:\"\n print e\n sys.exit()\n" }, { "path": "caffe2/contrib/cuda-convnet2/python_util/options.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport sys\nfrom getopt import getopt\nimport os\nimport re\n#import types\n\nTERM_BOLD_START = \"\\033[1m\"\nTERM_BOLD_END = \"\\033[0m\"\n\nclass Option:\n def __init__(self, letter, name, desc, parser, set_once, default, excuses, requires, save):\n assert not name is None\n self.letter = letter\n self.name = name\n self.desc = desc\n self.parser = parser\n self.set_once = set_once\n self.default = default\n self.excuses = excuses\n self.requires = requires\n self.save = save\n \n self.value = None\n self.value_given = False\n self.prefixed_letter = min(2, len(letter)) * '-' + letter\n \n def set_value(self, value, parse=True):\n try:\n self.value = self.parser.parse(value) if parse else value\n self.value_given = True\n# print self.name, self.value\n except OptionException, e:\n raise OptionException(\"Unable to parse option %s (%s): %s\" % (self.prefixed_letter, self.desc, e))\n \n def set_default(self):\n if not self.default is None:\n self.value = self.default\n \n def eval_expr_default(self, env):\n try:\n if isinstance(self.default, OptionExpression) and not self.value_given:\n self.value = self.default.evaluate(env)\n if not self.parser.is_type(self.value):\n raise OptionException(\"expression result %s is not of right type (%s)\" % (self.value, self.parser.get_type_str()))\n except Exception, e:\n raise OptionException(\"Unable to set default value for option %s (%s): %s\" % (self.prefixed_letter, self.desc, e))\n \n def get_str_value(self, get_default_str=False):\n val = self.value\n if get_default_str: val = self.default\n if val is None: return \"\"\n if isinstance(val, OptionExpression):\n return val.expr\n return self.parser.to_string(val)\n\nclass OptionsParser:\n \"\"\"An option parsing class. All options without default values are mandatory, unless a excuses\n option (usually a load file) is given.\n Does not support options without arguments.\"\"\"\n SORT_LETTER = 1\n SORT_DESC = 2\n SORT_EXPR_LAST = 3\n EXCUSE_ALL = \"all\"\n def __init__(self):\n self.options = {}\n \n def add_option(self, letter, name, parser, desc, set_once=False, default=None, excuses=[], requires=[], save=True):\n \"\"\"\n The letter parameter is the actual parameter that the user will have to supply on the command line.\n The name parameter is some name to be given to this option and must be a valid python variable name.\n \n An explanation of the \"default\" parameter:\n The default value, if specified, should have the same type as the option.\n You can also specify an expression as the default value. In this case, the default value of the parameter\n will be the output of the expression. The expression may assume all other option names\n as local variables. For example, you can define the hidden bias\n learning rate to be 10 times the weight learning rate by setting this default:\n \n default=OptionExpression(\"eps_w * 10\") (assuming an option named eps_w exists).\n \n However, it is up to you to make sure you do not make any circular expression definitions.\n \n Note that the order in which the options are parsed is arbitrary.\n In particular, expression default values that depend on other expression default values\n will often raise errors (depending on the order in which they happen to be parsed).\n Therefore it is best not to make the default value of one variable depend on the value\n of another if the other variable's default value is itself an expression.\n \n An explanation of the \"excuses\" parameter:\n All options are mandatory, but certain options can exclude other options from being mandatory.\n For example, if the excuses parameter for option \"load_file\" is [\"num_hid\", \"num_vis\"],\n then the options num_hid and num_vis are not mandatory as long as load_file is specified.\n Use the special flag EXCUSE_ALL to allow an option to make all other options optional.\n \"\"\"\n \n assert name not in self.options\n self.options[name] = Option(letter, name, desc, parser, set_once, default, excuses, requires, save)\n \n def set_value(self, name, value, parse=True):\n self.options[name].set_value(value, parse=parse)\n \n def get_value(self, name):\n return self.options[name].value\n \n def delete_option(self, name):\n if name in self.options:\n del self.options[name]\n \n def parse(self, eval_expr_defaults=False):\n \"\"\"Parses the options in sys.argv based on the options added to this parser. The\n default behavior is to leave any expression default options as OptionExpression objects.\n Set eval_expr_defaults=True to circumvent this.\"\"\"\n short_opt_str = ''.join([\"%s:\" % self.options[name].letter for name in self.options if len(self.options[name].letter) == 1])\n long_opts = [\"%s=\" % self.options[name].letter for name in self.options if len(self.options[name].letter) > 1]\n (go, ga) = getopt(sys.argv[1:], short_opt_str, longopts=long_opts)\n dic = dict(go)\n \n for o in self.get_options_list(sort_order=self.SORT_EXPR_LAST):\n if o.prefixed_letter in dic: \n o.set_value(dic[o.prefixed_letter])\n else:\n # check if excused or has default\n excused = max([o2.prefixed_letter in dic for o2 in self.options.values() if o2.excuses == self.EXCUSE_ALL or o.name in o2.excuses])\n if not excused and o.default is None:\n raise OptionMissingException(\"Option %s (%s) not supplied\" % (o.prefixed_letter, o.desc))\n o.set_default()\n # check requirements\n if o.prefixed_letter in dic:\n for o2 in self.get_options_list(sort_order=self.SORT_LETTER):\n if o2.name in o.requires and o2.prefixed_letter not in dic:\n raise OptionMissingException(\"Option %s (%s) requires option %s (%s)\" % (o.prefixed_letter, o.desc,\n o2.prefixed_letter, o2.desc))\n if eval_expr_defaults:\n self.eval_expr_defaults()\n return self.options\n \n def merge_from(self, op2):\n \"\"\"Merges the options in op2 into this instance, but does not overwrite\n this instances's SET options with op2's default values.\"\"\"\n for name, o in self.options.iteritems():\n if name in op2.options and ((op2.options[name].value_given and op2.options[name].value != self.options[name].value) or not op2.options[name].save):\n if op2.options[name].set_once:\n raise OptionException(\"Option %s (%s) cannot be changed\" % (op2.options[name].prefixed_letter, op2.options[name].desc))\n self.options[name] = op2.options[name]\n for name in op2.options:\n if name not in self.options:\n self.options[name] = op2.options[name]\n \n def eval_expr_defaults(self):\n env = dict([(name, o.value) for name, o in self.options.iteritems()])\n for o in self.options.values():\n o.eval_expr_default(env)\n \n def all_values_given(self):\n return max([o.value_given for o in self.options.values() if o.default is not None])\n \n def get_options_list(self, sort_order=SORT_LETTER):\n \"\"\" Returns the list of Option objects in this OptionParser,\n sorted as specified\"\"\"\n \n cmp = lambda x, y: (x.desc < y.desc and -1 or 1)\n if sort_order == self.SORT_LETTER:\n cmp = lambda x, y: (x.letter < y.letter and -1 or 1)\n elif sort_order == self.SORT_EXPR_LAST:\n cmp = lambda x, y: (type(x.default) == OptionExpression and 1 or -1)\n return sorted(self.options.values(), cmp=cmp)\n \n def print_usage(self, print_constraints=False):\n print \"%s usage:\" % os.path.basename(sys.argv[0])\n opslist = self.get_options_list()\n\n usage_strings = []\n num_def = 0\n for o in opslist:\n excs = ' '\n if o.default is None:\n excs = ', '.join(sorted([o2.prefixed_letter for o2 in self.options.values() if o2.excuses == self.EXCUSE_ALL or o.name in o2.excuses]))\n reqs = ', '.join(sorted([o2.prefixed_letter for o2 in self.options.values() if o2.name in o.requires]))\n usg = (OptionsParser._bold(o.prefixed_letter) + \" <%s>\" % o.parser.get_type_str(), o.desc, (\"[%s]\" % o.get_str_value(get_default_str=True)) if not o.default is None else None, excs, reqs)\n if o.default is None:\n usage_strings += [usg]\n else:\n usage_strings.insert(num_def, usg)\n num_def += 1\n \n col_widths = [self._longest_value(usage_strings, key=lambda x:x[i]) for i in range(len(usage_strings[0]) - 1)]\n\n col_names = [\" Option\", \"Description\", \"Default\"]\n if print_constraints:\n col_names += [\"Excused by\", \"Requires\"]\n for i, s in enumerate(col_names):\n print self._bold(s.ljust(col_widths[i])),\n\n print \"\"\n for l, d, de, ex, req in usage_strings:\n if de is None:\n de = ' '\n print (\" %s -\" % l.ljust(col_widths[0])), d.ljust(col_widths[1]), de.ljust(col_widths[2]),\n else:\n print (\" [%s] -\" % l.ljust(col_widths[0])), d.ljust(col_widths[1]), de.ljust(col_widths[2]),\n if print_constraints:\n print ex.ljust(col_widths[3]), req\n else:\n print \"\"\n \n def print_values(self):\n longest_desc = self._longest_value(self.options.values(), key=lambda x:x.desc)\n longest_def_value = self._longest_value([v for v in self.options.values() if not v.value_given and not v.default is None],\n key=lambda x:x.get_str_value())\n for o in self.get_options_list(sort_order=self.SORT_DESC):\n print \"%s: %s %s\" % (o.desc.ljust(longest_desc), o.get_str_value().ljust(longest_def_value), (not o.value_given and not o.default is None) and \"[DEFAULT]\" or \"\")\n \n @staticmethod\n def _longest_value(values, key=lambda x:x):\n mylen = lambda x: 0 if x is None else len(x)\n return mylen(key(max(values, key=lambda x:mylen(key(x)))))\n\n @staticmethod\n def _bold(str):\n return TERM_BOLD_START + str + TERM_BOLD_END\n\nclass OptionException(Exception):\n pass\n \nclass OptionMissingException(OptionException):\n pass\n\nclass OptionParser:\n @staticmethod\n def parse(value):\n return str(value)\n \n @staticmethod\n def to_string(value):\n return str(value)\n \n @staticmethod\n def get_type_str():\n pass\n \nclass IntegerOptionParser(OptionParser):\n @staticmethod\n def parse(value):\n try:\n return int(value)\n except:\n raise OptionException(\"argument is not an integer\")\n \n @staticmethod\n def get_type_str():\n return \"int\"\n \n @staticmethod\n def is_type(value):\n return type(value) == int\n \nclass BooleanOptionParser(OptionParser):\n @staticmethod\n def parse(value):\n try:\n v = int(value)\n if not v in (0,1):\n raise OptionException\n return v\n except:\n raise OptionException(\"argument is not a boolean\")\n \n @staticmethod\n def get_type_str():\n return \"0/1\"\n \n @staticmethod\n def is_type(value):\n return type(value) == int and value in (0, 1)\n \nclass StringOptionParser(OptionParser): \n @staticmethod\n def get_type_str():\n return \"string\"\n \n @staticmethod\n def is_type(value):\n return type(value) == str\n \nclass FloatOptionParser(OptionParser):\n @staticmethod\n def parse(value):\n try:\n return float(value)\n except:\n raise OptionException(\"argument is not a float\")\n \n @staticmethod\n def to_string(value):\n return \"%.6g\" % value\n \n @staticmethod\n def get_type_str():\n return \"float\"\n \n @staticmethod\n def is_type(value):\n return type(value) == float\n \nclass RangeOptionParser(OptionParser):\n @staticmethod\n def parse(value):\n m = re.match(\"^(\\d+)\\-(\\d+)$\", value)\n try:\n if m: return range(int(m.group(1)), int(m.group(2)) + 1)\n return [int(value)]\n except:\n raise OptionException(\"argument is neither an integer nor a range\")\n \n @staticmethod\n def to_string(value):\n return \"%d-%d\" % (value[0], value[-1])\n \n @staticmethod\n def get_type_str():\n return \"int[-int]\"\n \n @staticmethod\n def is_type(value):\n return type(value) == list\n \nclass ListOptionParser(OptionParser):\n \"\"\"\n A parser that parses a delimited list of items. If the \"parsers\"\n argument is a list of parsers, then the list of items must have the form and length\n specified by that list. \n \n Example:\n ListOptionParser([FloatOptionParser, IntegerOptionParser])\n \n would parse \"0.5,3\" but not \"0.5,3,0.6\" or \"0.5\" or \"3,0.5\".\n \n If the \"parsers\" argument is another parser, then the list of items may be of\n arbitrary length, but each item must be parseable by the given parser.\n \n Example:\n ListOptionParser(FloatOptionParser)\n \n would parse \"0.5\" and \"0.5,0.3\" and \"0.5,0.3,0.6\", etc.\n \"\"\"\n def __init__(self, parsers, sepchar=','):\n self.parsers = parsers\n self.sepchar = sepchar\n \n def parse(self, value):\n values = value.split(self.sepchar)\n if type(self.parsers) == list and len(values) != len(self.parsers):\n raise OptionException(\"requires %d arguments, given %d\" % (len(self.parsers), len(values)))\n \n try:\n if type(self.parsers) == list:\n return [p.parse(v) for p, v in zip(self.parsers, values)]\n return [self.parsers.parse(v) for v in values]\n except:\n raise OptionException(\"argument is not of the form %s\" % self.get_type_str())\n \n def to_string(self, value):\n if type(self.parsers) == list:\n return self.sepchar.join([p.to_string(v) for p, v in zip(self.parsers, value)])\n return self.sepchar.join([self.parsers.to_string(v) for v in value])\n \n def get_type_str(self):\n if type(self.parsers) == list:\n return self.sepchar.join([p.get_type_str() for p in self.parsers])\n return \"%s%s...\" % (self.parsers.get_type_str(), self.sepchar)\n \n @staticmethod\n def is_type(value):\n return type(value) == list\n \nclass OptionExpression:\n \"\"\"\n This allows you to specify option values in terms of other option values.\n Example:\n op.add_option(\"eps-w\", \"eps_w\", ListOptionParser(FloatOptionParser), \"Weight learning rates for each layer\")\n op.add_option(\"eps-b\", \"eps_b\", ListOptionParser(FloatOptionParser), \"Bias learning rates for each layer\", default=OptionExpression(\"[o * 10 for o in eps_w]\"))\n \n This says: the default bias learning rate for each layer is 10\n times the weight learning rate for that layer.\n \"\"\"\n def __init__(self, expr):\n self.expr = expr\n \n def evaluate(self, options):\n locals().update(options)\n try:\n return eval(self.expr)\n except Exception, e:\n raise OptionException(\"expression '%s': unable to parse: %s\" % (self.expr, e))\n" }, { "path": "caffe2/contrib/cuda-convnet2/python_util/util.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport re\nimport cPickle\nimport os\nfrom cStringIO import StringIO\n\nclass UnpickleError(Exception):\n pass\n\nGPU_LOCK_NO_SCRIPT = -2\nGPU_LOCK_NO_LOCK = -1\n\ndef pickle(filename, data):\n fo = filename\n if type(filename) == str:\n fo = open(filename, \"w\")\n \n cPickle.dump(data, fo, protocol=cPickle.HIGHEST_PROTOCOL)\n fo.close()\n \ndef unpickle(filename):\n if not os.path.exists(filename):\n raise UnpickleError(\"Path '%s' does not exist.\" % filename)\n\n fo = open(filename, 'r')\n z = StringIO()\n file_size = os.fstat(fo.fileno()).st_size\n # Read 1GB at a time to avoid overflow\n while fo.tell() < file_size:\n z.write(fo.read(1 << 30))\n fo.close()\n dict = cPickle.loads(z.getvalue())\n z.close()\n \n return dict\n\ndef is_intel_machine():\n VENDOR_ID_REGEX = re.compile('^vendor_id\\s+: (\\S+)')\n f = open('/proc/cpuinfo')\n for line in f:\n m = VENDOR_ID_REGEX.match(line)\n if m:\n f.close()\n return m.group(1) == 'GenuineIntel'\n f.close()\n return False\n\n# Returns the CPUs associated with a given GPU\ndef get_cpus_for_gpu(gpu):\n #proc = subprocess.Popen(['nvidia-smi', '-q', '-i', str(gpu)], stdout=subprocess.PIPE)\n #lines = proc.communicate()[0]\n #lines = subprocess.check_output(['nvidia-smi', '-q', '-i', str(gpu)]).split(os.linesep)\n\n with open('/proc/driver/nvidia/gpus/%d/information' % gpu) as f:\n for line in f:\n if line.startswith('Bus Location'):\n bus_id = line.split(':', 1)[1].strip()\n bus_id = bus_id[:7] + ':' + bus_id[8:]\n ff = open('/sys/module/nvidia/drivers/pci:nvidia/%s/local_cpulist' % bus_id)\n cpus_str = ff.readline()\n ff.close()\n cpus = [cpu for s in cpus_str.split(',') for cpu in range(int(s.split('-')[0]),int(s.split('-')[1])+1)]\n return cpus\n return [-1]\n\ndef get_cpu():\n if is_intel_machine():\n return 'intel'\n return 'amd'\n\ndef is_windows_machine():\n return os.name == 'nt'\n \ndef tryint(s):\n try:\n return int(s)\n except:\n return s\n\ndef alphanum_key(s):\n return [tryint(c) for c in re.split('([0-9]+)', s)]\n" }, { "path": "caffe2/contrib/cuda-convnet2/shownet.py", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport os\nimport sys\nfrom tarfile import TarFile, TarInfo\nfrom matplotlib import pylab as pl\nimport numpy as n\nimport getopt as opt\nfrom python_util.util import *\nfrom math import sqrt, ceil, floor\nfrom python_util.gpumodel import IGPUModel\nimport random as r\nimport numpy.random as nr\nfrom convnet import ConvNet\nfrom python_util.options import *\nfrom PIL import Image\nfrom time import sleep\n\nclass ShowNetError(Exception):\n pass\n\nclass ShowConvNet(ConvNet):\n def __init__(self, op, load_dic):\n ConvNet.__init__(self, op, load_dic)\n\n def init_data_providers(self):\n self.need_gpu = self.op.get_value('show_preds') \n class Dummy:\n def advance_batch(self):\n pass\n if self.need_gpu:\n ConvNet.init_data_providers(self)\n else:\n self.train_data_provider = self.test_data_provider = Dummy()\n \n def import_model(self):\n if self.need_gpu:\n ConvNet.import_model(self)\n \n def init_model_state(self):\n if self.op.get_value('show_preds'):\n self.softmax_name = self.op.get_value('show_preds')\n \n def init_model_lib(self):\n if self.need_gpu:\n ConvNet.init_model_lib(self)\n\n def plot_cost(self):\n if self.show_cost not in self.train_outputs[0][0]:\n raise ShowNetError(\"Cost function with name '%s' not defined by given convnet.\" % self.show_cost)\n# print self.test_outputs\n train_errors = [eval(self.layers[self.show_cost]['outputFilter'])(o[0][self.show_cost], o[1])[self.cost_idx] for o in self.train_outputs]\n test_errors = [eval(self.layers[self.show_cost]['outputFilter'])(o[0][self.show_cost], o[1])[self.cost_idx] for o in self.test_outputs]\n if self.smooth_test_errors:\n test_errors = [sum(test_errors[max(0,i-len(self.test_batch_range)):i])/(i-max(0,i-len(self.test_batch_range))) for i in xrange(1,len(test_errors)+1)]\n numbatches = len(self.train_batch_range)\n test_errors = n.row_stack(test_errors)\n test_errors = n.tile(test_errors, (1, self.testing_freq))\n test_errors = list(test_errors.flatten())\n test_errors += [test_errors[-1]] * max(0,len(train_errors) - len(test_errors))\n test_errors = test_errors[:len(train_errors)]\n\n numepochs = len(train_errors) / float(numbatches)\n pl.figure(1)\n x = range(0, len(train_errors))\n pl.plot(x, train_errors, 'k-', label='Training set')\n pl.plot(x, test_errors, 'r-', label='Test set')\n pl.legend()\n ticklocs = range(numbatches, len(train_errors) - len(train_errors) % numbatches + 1, numbatches)\n epoch_label_gran = int(ceil(numepochs / 20.)) \n epoch_label_gran = int(ceil(float(epoch_label_gran) / 10) * 10) if numepochs >= 10 else epoch_label_gran \n ticklabels = map(lambda x: str((x[1] / numbatches)) if x[0] % epoch_label_gran == epoch_label_gran-1 else '', enumerate(ticklocs))\n\n pl.xticks(ticklocs, ticklabels)\n pl.xlabel('Epoch')\n# pl.ylabel(self.show_cost)\n pl.title('%s[%d]' % (self.show_cost, self.cost_idx))\n# print \"plotted cost\"\n \n def make_filter_fig(self, filters, filter_start, fignum, _title, num_filters, combine_chans, FILTERS_PER_ROW=16):\n MAX_ROWS = 24\n MAX_FILTERS = FILTERS_PER_ROW * MAX_ROWS\n num_colors = filters.shape[0]\n f_per_row = int(ceil(FILTERS_PER_ROW / float(1 if combine_chans else num_colors)))\n filter_end = min(filter_start+MAX_FILTERS, num_filters)\n filter_rows = int(ceil(float(filter_end - filter_start) / f_per_row))\n \n filter_pixels = filters.shape[1]\n filter_size = int(sqrt(filters.shape[1]))\n fig = pl.figure(fignum)\n fig.text(.5, .95, '%s %dx%d filters %d-%d' % (_title, filter_size, filter_size, filter_start, filter_end-1), horizontalalignment='center') \n num_filters = filter_end - filter_start\n if not combine_chans:\n bigpic = n.zeros((filter_size * filter_rows + filter_rows + 1, filter_size*num_colors * f_per_row + f_per_row + 1), dtype=n.single)\n else:\n bigpic = n.zeros((3, filter_size * filter_rows + filter_rows + 1, filter_size * f_per_row + f_per_row + 1), dtype=n.single)\n \n for m in xrange(filter_start,filter_end ):\n filter = filters[:,:,m]\n y, x = (m - filter_start) / f_per_row, (m - filter_start) % f_per_row\n if not combine_chans:\n for c in xrange(num_colors):\n filter_pic = filter[c,:].reshape((filter_size,filter_size))\n bigpic[1 + (1 + filter_size) * y:1 + (1 + filter_size) * y + filter_size,\n 1 + (1 + filter_size*num_colors) * x + filter_size*c:1 + (1 + filter_size*num_colors) * x + filter_size*(c+1)] = filter_pic\n else:\n filter_pic = filter.reshape((3, filter_size,filter_size))\n bigpic[:,\n 1 + (1 + filter_size) * y:1 + (1 + filter_size) * y + filter_size,\n 1 + (1 + filter_size) * x:1 + (1 + filter_size) * x + filter_size] = filter_pic\n \n pl.xticks([])\n pl.yticks([])\n if not combine_chans:\n pl.imshow(bigpic, cmap=pl.cm.gray, interpolation='nearest')\n else:\n bigpic = bigpic.swapaxes(0,2).swapaxes(0,1)\n pl.imshow(bigpic, interpolation='nearest') \n \n def plot_filters(self):\n FILTERS_PER_ROW = 16\n filter_start = 0 # First filter to show\n if self.show_filters not in self.layers:\n raise ShowNetError(\"Layer with name '%s' not defined by given convnet.\" % self.show_filters)\n layer = self.layers[self.show_filters]\n filters = layer['weights'][self.input_idx]\n# filters = filters - filters.min()\n# filters = filters / filters.max()\n if layer['type'] == 'fc': # Fully-connected layer\n num_filters = layer['outputs']\n channels = self.channels\n filters = filters.reshape(channels, filters.shape[0]/channels, filters.shape[1])\n elif layer['type'] in ('conv', 'local'): # Conv layer\n num_filters = layer['filters']\n channels = layer['filterChannels'][self.input_idx]\n if layer['type'] == 'local':\n filters = filters.reshape((layer['modules'], channels, layer['filterPixels'][self.input_idx], num_filters))\n filters = filters[:, :, :, self.local_plane] # first map for now (modules, channels, pixels)\n filters = filters.swapaxes(0,2).swapaxes(0,1)\n num_filters = layer['modules']\n# filters = filters.swapaxes(0,1).reshape(channels * layer['filterPixels'][self.input_idx], num_filters * layer['modules'])\n# num_filters *= layer['modules']\n FILTERS_PER_ROW = layer['modulesX']\n else:\n filters = filters.reshape(channels, filters.shape[0]/channels, filters.shape[1])\n \n \n # Convert YUV filters to RGB\n if self.yuv_to_rgb and channels == 3:\n R = filters[0,:,:] + 1.28033 * filters[2,:,:]\n G = filters[0,:,:] + -0.21482 * filters[1,:,:] + -0.38059 * filters[2,:,:]\n B = filters[0,:,:] + 2.12798 * filters[1,:,:]\n filters[0,:,:], filters[1,:,:], filters[2,:,:] = R, G, B\n combine_chans = not self.no_rgb and channels == 3\n \n # Make sure you don't modify the backing array itself here -- so no -= or /=\n if self.norm_filters:\n #print filters.shape\n filters = filters - n.tile(filters.reshape((filters.shape[0] * filters.shape[1], filters.shape[2])).mean(axis=0).reshape(1, 1, filters.shape[2]), (filters.shape[0], filters.shape[1], 1))\n filters = filters / n.sqrt(n.tile(filters.reshape((filters.shape[0] * filters.shape[1], filters.shape[2])).var(axis=0).reshape(1, 1, filters.shape[2]), (filters.shape[0], filters.shape[1], 1)))\n #filters = filters - n.tile(filters.min(axis=0).min(axis=0), (3, filters.shape[1], 1))\n #filters = filters / n.tile(filters.max(axis=0).max(axis=0), (3, filters.shape[1], 1))\n #else:\n filters = filters - filters.min()\n filters = filters / filters.max()\n\n self.make_filter_fig(filters, filter_start, 2, 'Layer %s' % self.show_filters, num_filters, combine_chans, FILTERS_PER_ROW=FILTERS_PER_ROW)\n \n def plot_predictions(self):\n epoch, batch, data = self.get_next_batch(train=False) # get a test batch\n num_classes = self.test_data_provider.get_num_classes()\n NUM_ROWS = 2\n NUM_COLS = 4\n NUM_IMGS = NUM_ROWS * NUM_COLS if not self.save_preds else data[0].shape[1]\n NUM_TOP_CLASSES = min(num_classes, 5) # show this many top labels\n NUM_OUTPUTS = self.model_state['layers'][self.softmax_name]['outputs']\n PRED_IDX = 1\n \n label_names = [lab.split(',')[0] for lab in self.test_data_provider.batch_meta['label_names']]\n if self.only_errors:\n preds = n.zeros((data[0].shape[1], NUM_OUTPUTS), dtype=n.single)\n else:\n preds = n.zeros((NUM_IMGS, NUM_OUTPUTS), dtype=n.single)\n #rand_idx = nr.permutation(n.r_[n.arange(1), n.where(data[1] == 552)[1], n.where(data[1] == 795)[1], n.where(data[1] == 449)[1], n.where(data[1] == 274)[1]])[:NUM_IMGS]\n rand_idx = nr.randint(0, data[0].shape[1], NUM_IMGS)\n if NUM_IMGS < data[0].shape[1]:\n data = [n.require(d[:,rand_idx], requirements='C') for d in data]\n# data += [preds]\n # Run the model\n print [d.shape for d in data], preds.shape\n self.libmodel.startFeatureWriter(data, [preds], [self.softmax_name])\n IGPUModel.finish_batch(self)\n print preds\n data[0] = self.test_data_provider.get_plottable_data(data[0])\n\n if self.save_preds:\n if not gfile.Exists(self.save_preds):\n gfile.MakeDirs(self.save_preds)\n preds_thresh = preds > 0.5 # Binarize predictions\n data[0] = data[0] * 255.0\n data[0][data[0]<0] = 0\n data[0][data[0]>255] = 255\n data[0] = n.require(data[0], dtype=n.uint8)\n dir_name = '%s_predictions_batch_%d' % (os.path.basename(self.save_file), batch)\n tar_name = os.path.join(self.save_preds, '%s.tar' % dir_name)\n tfo = gfile.GFile(tar_name, \"w\")\n tf = TarFile(fileobj=tfo, mode='w')\n for img_idx in xrange(NUM_IMGS):\n img = data[0][img_idx,:,:,:]\n imsave = Image.fromarray(img)\n prefix = \"CORRECT\" if data[1][0,img_idx] == preds_thresh[img_idx,PRED_IDX] else \"FALSE_POS\" if preds_thresh[img_idx,PRED_IDX] == 1 else \"FALSE_NEG\"\n file_name = \"%s_%.2f_%d_%05d_%d.png\" % (prefix, preds[img_idx,PRED_IDX], batch, img_idx, data[1][0,img_idx])\n# gf = gfile.GFile(file_name, \"w\")\n file_string = StringIO()\n imsave.save(file_string, \"PNG\")\n tarinf = TarInfo(os.path.join(dir_name, file_name))\n tarinf.size = file_string.tell()\n file_string.seek(0)\n tf.addfile(tarinf, file_string)\n tf.close()\n tfo.close()\n# gf.close()\n print \"Wrote %d prediction PNGs to %s\" % (preds.shape[0], tar_name)\n else:\n fig = pl.figure(3, figsize=(12,9))\n fig.text(.4, .95, '%s test samples' % ('Mistaken' if self.only_errors else 'Random'))\n if self.only_errors:\n # what the net got wrong\n if NUM_OUTPUTS > 1:\n err_idx = [i for i,p in enumerate(preds.argmax(axis=1)) if p not in n.where(data[2][:,i] > 0)[0]]\n else:\n err_idx = n.where(data[1][0,:] != preds[:,0].T)[0]\n print err_idx\n err_idx = r.sample(err_idx, min(len(err_idx), NUM_IMGS))\n data[0], data[1], preds = data[0][:,err_idx], data[1][:,err_idx], preds[err_idx,:]\n \n \n import matplotlib.gridspec as gridspec\n import matplotlib.colors as colors\n cconv = colors.ColorConverter()\n gs = gridspec.GridSpec(NUM_ROWS*2, NUM_COLS,\n width_ratios=[1]*NUM_COLS, height_ratios=[2,1]*NUM_ROWS )\n #print data[1]\n for row in xrange(NUM_ROWS):\n for col in xrange(NUM_COLS):\n img_idx = row * NUM_COLS + col\n if data[0].shape[0] <= img_idx:\n break\n pl.subplot(gs[(row * 2) * NUM_COLS + col])\n #pl.subplot(NUM_ROWS*2, NUM_COLS, row * 2 * NUM_COLS + col + 1)\n pl.xticks([])\n pl.yticks([])\n img = data[0][img_idx,:,:,:]\n pl.imshow(img, interpolation='lanczos')\n show_title = data[1].shape[0] == 1\n true_label = [int(data[1][0,img_idx])] if show_title else n.where(data[1][:,img_idx]==1)[0]\n #print true_label\n #print preds[img_idx,:].shape\n #print preds[img_idx,:].max()\n true_label_names = [label_names[i] for i in true_label]\n img_labels = sorted(zip(preds[img_idx,:], label_names), key=lambda x: x[0])[-NUM_TOP_CLASSES:]\n #print img_labels\n axes = pl.subplot(gs[(row * 2 + 1) * NUM_COLS + col])\n height = 0.5\n ylocs = n.array(range(NUM_TOP_CLASSES))*height\n pl.barh(ylocs, [l[0] for l in img_labels], height=height, \\\n color=['#ffaaaa' if l[1] in true_label_names else '#aaaaff' for l in img_labels])\n #pl.title(\", \".join(true_labels))\n if show_title:\n pl.title(\", \".join(true_label_names), fontsize=15, fontweight='bold')\n else:\n print true_label_names\n pl.yticks(ylocs + height/2, [l[1] for l in img_labels], x=1, backgroundcolor=cconv.to_rgba('0.65', alpha=0.5), weight='bold')\n for line in enumerate(axes.get_yticklines()): \n line[1].set_visible(False) \n #pl.xticks([width], [''])\n #pl.yticks([])\n pl.xticks([])\n pl.ylim(0, ylocs[-1] + height)\n pl.xlim(0, 1)\n\n def start(self):\n self.op.print_values()\n# print self.show_cost\n if self.show_cost:\n self.plot_cost()\n if self.show_filters:\n self.plot_filters()\n if self.show_preds:\n self.plot_predictions()\n\n if pl:\n pl.show()\n sys.exit(0)\n \n @classmethod\n def get_options_parser(cls):\n op = ConvNet.get_options_parser()\n for option in list(op.options):\n if option not in ('gpu', 'load_file', 'inner_size', 'train_batch_range', 'test_batch_range', 'multiview_test', 'data_path', 'pca_noise', 'scalar_mean'):\n op.delete_option(option)\n op.add_option(\"show-cost\", \"show_cost\", StringOptionParser, \"Show specified objective function\", default=\"\")\n op.add_option(\"show-filters\", \"show_filters\", StringOptionParser, \"Show learned filters in specified layer\", default=\"\")\n op.add_option(\"norm-filters\", \"norm_filters\", BooleanOptionParser, \"Individually normalize filters shown with --show-filters\", default=0)\n op.add_option(\"input-idx\", \"input_idx\", IntegerOptionParser, \"Input index for layer given to --show-filters\", default=0)\n op.add_option(\"cost-idx\", \"cost_idx\", IntegerOptionParser, \"Cost function return value index for --show-cost\", default=0)\n op.add_option(\"no-rgb\", \"no_rgb\", BooleanOptionParser, \"Don't combine filter channels into RGB in layer given to --show-filters\", default=False)\n op.add_option(\"yuv-to-rgb\", \"yuv_to_rgb\", BooleanOptionParser, \"Convert RGB filters to YUV in layer given to --show-filters\", default=False)\n op.add_option(\"channels\", \"channels\", IntegerOptionParser, \"Number of channels in layer given to --show-filters (fully-connected layers only)\", default=0)\n op.add_option(\"show-preds\", \"show_preds\", StringOptionParser, \"Show predictions made by given softmax on test set\", default=\"\")\n op.add_option(\"save-preds\", \"save_preds\", StringOptionParser, \"Save predictions to given path instead of showing them\", default=\"\")\n op.add_option(\"only-errors\", \"only_errors\", BooleanOptionParser, \"Show only mistaken predictions (to be used with --show-preds)\", default=False, requires=['show_preds'])\n op.add_option(\"local-plane\", \"local_plane\", IntegerOptionParser, \"Local plane to show\", default=0)\n op.add_option(\"smooth-test-errors\", \"smooth_test_errors\", BooleanOptionParser, \"Use running average for test error plot?\", default=1)\n\n op.options['load_file'].default = None\n return op\n \nif __name__ == \"__main__\":\n #nr.seed(6)\n try:\n op = ShowConvNet.get_options_parser()\n op, load_dic = IGPUModel.parse_options(op)\n model = ShowConvNet(op, load_dic)\n model.start()\n except (UnpickleError, ShowNetError, opt.GetoptError), e:\n print \"----------------\"\n print \"Error:\"\n print e \n" }, { "path": "caffe2/contrib/cuda-convnet2/util/Makefile", "content": "# Copyright 2014 Google Inc. All rights reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nLINK_LIBS := -L$(ATLAS_LIB_PATH) -latlas -lcblas\nINCLUDES := -I./include\nCOMMONFLAGS :=\nCC_ARGS := \nCC=g++\n\nifndef debug\n\tCC_ARGS += -O3\nendif\n\nOUT_DIR=./bin/$(OUT_SUFFIX)\nOUT_FILE=libutil.so\n\nifeq ($(numpy), 1)\n\tPYTHON_VERSION=$(shell python -V 2>&1 | cut -d ' ' -f 2 | cut -d '.' -f 1,2)\n\tLINK_LIBS += -lpython$(PYTHON_VERSION)\n\n\tINCLUDES += -I$(PYTHON_INCLUDE_PATH) -I$(NUMPY_INCLUDE_PATH)\n\tCOMMONFLAGS += -DNUMPY_INTERFACE\n\tOUT_FILE=libutilpy.so\nendif\n\nOBJECTS = matrix.cpp \n\nall: dir classes $(OUT_FILE)\n\ndir:\n\tmkdir -p $(OUT_DIR)/src\n\nSOURCES = $(shell echo src/*.cpp)\nCLASSES = $(SOURCES:.cpp=.o)\n\nclasses: $(CLASSES)\n\n%.o: %.cpp\n\t$(CC) $(CC_ARGS) -c -fPIC $(BUILD_ARGS) $(COMMONFLAGS) $(INCLUDES) $< -o $(OUT_DIR)/$*.o\n\n$(OUT_FILE): classes\n\tcd $(OUT_DIR) && $(CC) $(CC_ARGS) $(BUILD_ARGS) $(COMMONFLAGS) -shared -Wl,-no-undefined -o $(OUT_FILE) $(CLASSES) $(LINK_LIBS)\n\tln -sf $(OUT_DIR)/$(OUT_FILE) .\n\nclean:\n\trm -rf $(OUT_DIR)/*\n" }, { "path": "caffe2/contrib/cuda-convnet2/util/include/matrix.h", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef MATRIX_H_\n#define MATRIX_H_\n\n#include \"matrix_funcs.h\"\n#ifdef NUMPY_INTERFACE\n#include \n#include \n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n\nextern \"C\" {\n// #include \n#include \"caffe2/utils/cblas.h\"\n}\n\n#ifdef DOUBLE_PRECISION\n#define CBLAS_GEMM cblas_dgemm\n#define CBLAS_SCAL cblas_dscal\n#define CBLAS_AXPY cblas_daxpy\n#else\n#define CBLAS_GEMM cblas_sgemm\n#define CBLAS_SCAL cblas_sscal\n#define CBLAS_AXPY cblas_saxpy\n#endif /* DOUBLE_PRECISION */\n\n#define MTYPE_MAX numeric_limits::max()\n\ntypedef long long int int64;\n\nclass Matrix {\nprivate:\n MTYPE* _data;\n bool _ownsData;\n int64 _numRows, _numCols;\n int64 _numElements;\n CBLAS_TRANSPOSE _trans;\n\n void _init(MTYPE* data, int64 numRows, int64 numCols, bool transpose, bool ownsData);\n void _tileTo2(Matrix& target) const;\n void _copyAllTo(Matrix& target) const;\n MTYPE _sum_column(int64 col) const;\n MTYPE _sum_row(int64 row) const;\n MTYPE _aggregate(MTYPE(*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const;\n void _aggregate(int64 axis, Matrix& target, MTYPE(*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const;\n MTYPE _aggregateRow(int64 row, MTYPE(*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const;\n MTYPE _aggregateCol(int64 row, MTYPE(*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const;\n void _updateDims(int64 numRows, int64 numCols);\n void _applyLoop(MTYPE(*func)(MTYPE));\n void _applyLoop(MTYPE (*func)(MTYPE), Matrix& target);\n void _applyLoop2(const Matrix& a, MTYPE(*func)(MTYPE, MTYPE), Matrix& target) const;\n void _applyLoop2(const Matrix& a, MTYPE (*func)(MTYPE,MTYPE, MTYPE), MTYPE scalar, Matrix& target) const;\n void _applyLoop2(const Matrix& a, MTYPE (*func)(MTYPE,MTYPE, MTYPE, MTYPE), MTYPE scalar1, MTYPE scalar2, Matrix& target) const;\n void _applyLoopScalar(const MTYPE scalar, MTYPE(*func)(MTYPE, MTYPE), Matrix& target) const;\n void _checkBounds(int64 startRow, int64 endRow, int64 startCol, int64 endCol) const;\n void _divideByVector(const Matrix& vec, Matrix& target);\n inline int64 _getNumColsBackEnd() const {\n return _trans == CblasNoTrans ? _numCols : _numRows;\n }\npublic:\n enum FUNCTION {\n TANH, RECIPROCAL, SQUARE, ABS, EXP, LOG, ZERO, ONE, LOGISTIC1, LOGISTIC2, SIGN\n };\n Matrix();\n Matrix(int64 numRows, int64 numCols);\n Matrix(int64 numRows, int64 numCols, bool transpose);\n#ifdef NUMPY_INTERFACE\n Matrix(const PyArrayObject *src);\n#endif\n Matrix(const Matrix &like);\n Matrix(MTYPE* data, int64 numRows, int64 numCols);\n Matrix(MTYPE* data, int64 numRows, int64 numCols, bool transpose);\n ~Matrix();\n\n inline MTYPE& getCell(int64 i, int64 j) const {\n assert(i >= 0 && i < _numRows);\n assert(j >= 0 && j < _numCols);\n if (_trans == CblasTrans) {\n return _data[j * _numRows + i];\n }\n return _data[i * _numCols + j];\n }\n\n MTYPE& operator()(int64 i, int64 j) const {\n return getCell(i, j);\n }\n\n inline MTYPE* getData() const {\n return _data;\n }\n\n inline bool isView() const {\n return !_ownsData;\n }\n\n inline int64 getNumRows() const {\n return _numRows;\n }\n\n inline int64 getNumCols() const {\n return _numCols;\n }\n\n inline int64 getNumDataBytes() const {\n return _numElements * sizeof(MTYPE);\n }\n\n inline int64 getNumElements() const {\n return _numElements;\n }\n\n inline int64 getLeadingDim() const {\n return _trans == CblasTrans ? _numRows : _numCols;\n }\n\n inline int64 getFollowingDim() const {\n return _trans == CblasTrans ? _numCols : _numRows;\n }\n\n inline CBLAS_TRANSPOSE getBLASTrans() const {\n return _trans;\n }\n\n inline bool isSameDims(const Matrix& a) const {\n return a.getNumRows() == getNumRows() && a.getNumCols() == getNumCols();\n }\n\n inline bool isTrans() const {\n return _trans == CblasTrans;\n }\n\n /*\n * Only use if you know what you're doing!\n * Does not update any dimensions. Just flips the _trans flag.\n *\n * Use transpose() if you want to get the transpose of this matrix.\n */\n inline void setTrans(bool trans) {\n assert(isTrans() == trans || !isView());\n _trans = trans ? CblasTrans : CblasNoTrans;\n }\n\n void apply(FUNCTION f);\n void apply(Matrix::FUNCTION f, Matrix& target);\n void subtractFromScalar(MTYPE scalar);\n void subtractFromScalar(MTYPE scalar, Matrix &target) const;\n void biggerThanScalar(MTYPE scalar);\n void smallerThanScalar(MTYPE scalar);\n void equalsScalar(MTYPE scalar);\n void biggerThanScalar(MTYPE scalar, Matrix& target) const;\n void smallerThanScalar(MTYPE scalar, Matrix& target) const;\n void equalsScalar(MTYPE scalar, Matrix& target) const;\n void biggerThan(Matrix& a);\n void biggerThan(Matrix& a, Matrix& target) const;\n void smallerThan(Matrix& a);\n void smallerThan(Matrix& a, Matrix& target) const;\n void minWith(Matrix &a);\n void minWith(Matrix &a, Matrix &target) const;\n void maxWith(Matrix &a);\n void maxWith(Matrix &a, Matrix &target) const;\n void equals(Matrix& a);\n void equals(Matrix& a, Matrix& target) const;\n void notEquals(Matrix& a) ;\n void notEquals(Matrix& a, Matrix& target) const;\n void add(const Matrix &m);\n void add(const Matrix &m, MTYPE scale);\n void add(const Matrix &m, MTYPE scaleThis, MTYPE scaleM);\n void add(const Matrix &m, Matrix& target);\n void add(const Matrix &m, MTYPE scaleM, Matrix &target);\n void add(const Matrix &m, MTYPE scaleThis, MTYPE scaleM, Matrix &target);\n void subtract(const Matrix &m);\n void subtract(const Matrix &m, Matrix& target);\n void subtract(const Matrix &m, MTYPE scale);\n void subtract(const Matrix &m, MTYPE scale, Matrix& target);\n void addVector(const Matrix& vec, MTYPE scale);\n void addVector(const Matrix& vec, MTYPE scale, Matrix& target);\n void addVector(const Matrix& vec);\n void addVector(const Matrix& vec, Matrix& target);\n void addScalar(MTYPE scalar);\n void addScalar(MTYPE scalar, Matrix& target) const;\n void maxWithScalar(MTYPE scalar);\n void maxWithScalar(MTYPE scalar, Matrix &target) const;\n void minWithScalar(MTYPE scalar);\n void minWithScalar(MTYPE scalar, Matrix &target) const;\n void eltWiseMultByVector(const Matrix& vec);\n void eltWiseMultByVector(const Matrix& vec, Matrix& target);\n void eltWiseDivideByVector(const Matrix& vec);\n void eltWiseDivideByVector(const Matrix& vec, Matrix& target);\n void resize(int64 newNumRows, int64 newNumCols);\n void resize(const Matrix& like);\n Matrix& slice(int64 startRow, int64 endRow, int64 startCol, int64 endCol) const;\n void slice(int64 startRow, int64 endRow, int64 startCol, int64 endCol, Matrix &target) const;\n Matrix& sliceRows(int64 startRow, int64 endRow) const;\n void sliceRows(int64 startRow, int64 endRow, Matrix& target) const;\n Matrix& sliceCols(int64 startCol, int64 endCol) const;\n void sliceCols(int64 startCol, int64 endCol, Matrix& target) const;\n void rightMult(const Matrix &b, MTYPE scale);\n void rightMult(const Matrix &b, Matrix &target) const;\n void rightMult(const Matrix &b);\n void rightMult(const Matrix &b, MTYPE scaleAB, Matrix &target) const;\n void addProduct(const Matrix &a, const Matrix &b, MTYPE scaleAB, MTYPE scaleThis);\n void addProduct(const Matrix& a, const Matrix& b);\n void eltWiseMult(const Matrix& a);\n void eltWiseMult(const Matrix& a, Matrix& target) const;\n void eltWiseDivide(const Matrix& a);\n void eltWiseDivide(const Matrix& a, Matrix &target) const;\n Matrix& transpose() const;\n Matrix& transpose(bool hard) const;\n Matrix& tile(int64 timesY, int64 timesX) const;\n void tile(int64 timesY, int64 timesX, Matrix& target) const;\n void copy(Matrix &dest, int64 srcStartRow, int64 srcEndRow, int64 srcStartCol, int64 srcEndCol, int64 destStartRow, int64 destStartCol) const;\n Matrix& copy() const;\n void copy(Matrix& target) const;\n Matrix& sum(int64 axis) const;\n void sum(int64 axis, Matrix &target) const;\n MTYPE sum() const;\n MTYPE max() const;\n Matrix& max(int64 axis) const;\n void max(int64 axis, Matrix& target) const;\n MTYPE min() const;\n Matrix& min(int64 axis) const;\n void min(int64 axis, Matrix& target) const;\n MTYPE norm() const;\n MTYPE norm2() const;\n void scale(MTYPE scale);\n void scale(MTYPE alpha, Matrix& target);\n void reshape(int64 numRows, int64 numCols);\n Matrix& reshaped(int64 numRows, int64 numCols);\n void printShape(const char* name) const;\n bool hasNan() const;\n bool hasInf() const;\n\n void randomizeNormal(MTYPE mean, MTYPE stdev);\n void randomizeUniform();\n void randomizeNormal();\n void print() const;\n void print(int64 startRow,int64 rows, int64 startCol,int64 cols) const;\n void print(int64 rows, int64 cols) const;\n};\n\ntypedef std::vector MatrixV;\n\n#endif /* MATRIX_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/util/include/matrix_funcs.h", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef MATRIX_FUNCS_H_\n#define MATRIX_FUNCS_H_\n\n#include \n#include \n#include \n\n#ifdef DOUBLE_PRECISION\n#define MTYPE double\n#else\n#define MTYPE float\n#endif\n\n#define MYRAND ((double)rand() / ((double)RAND_MAX + 1))\n\ninline MTYPE _zero(MTYPE x) {\n return 0;\n}\n\ninline MTYPE _one(MTYPE x) {\n return 1;\n}\n\ninline MTYPE _abs(MTYPE x) {\n return x > 0 ? x : -x;\n}\n\ninline MTYPE _square(MTYPE x) {\n return x * x;\n}\n\ninline MTYPE _sigma1(MTYPE x) {\n return (tanh(x / 2) + 1) / 2;\n}\n\ninline MTYPE _sigma2(MTYPE x) {\n return 1 / (1 + exp(-x));\n}\n\ninline MTYPE _recip(MTYPE x) {\n return 1 / x;\n}\n\ninline MTYPE _exp(MTYPE x) {\n return exp(x);\n}\n\ninline MTYPE _log(MTYPE x) {\n return log(x);\n}\n\ninline MTYPE _tanh(MTYPE x) {\n return tanh(x);\n}\n\ninline MTYPE _sign(MTYPE x) {\n return x > 0 ? 1 : -1;\n}\n\ninline MTYPE _rand(MTYPE x) {\n return MYRAND;\n}\n\ninline MTYPE _divide(MTYPE x, MTYPE y) {\n return x / y;\n}\n\ninline MTYPE _mult(MTYPE x, MTYPE y) {\n return x * y;\n}\n\ninline MTYPE _add(MTYPE x, MTYPE y) {\n return x + y;\n}\n\ninline MTYPE _addSquare(MTYPE x, MTYPE y) {\n return x*x + y;\n}\n\ninline MTYPE _addWithScale(MTYPE x, MTYPE y, MTYPE scale) {\n return x + scale*y;\n}\n\ninline MTYPE _addWithScale2(MTYPE x, MTYPE y, MTYPE scaleThis, MTYPE scaleM) {\n return scaleThis * x + scaleM * y;\n}\n\ninline MTYPE _max(MTYPE x, MTYPE y) {\n return std::max(x, y);\n}\n\ninline MTYPE _min(MTYPE x, MTYPE y) {\n return std::min(x, y);\n}\n\ninline MTYPE _bigger(MTYPE x, MTYPE y) {\n return x > y;\n}\n\ninline MTYPE _smaller(MTYPE x, MTYPE y) {\n return x < y;\n}\n\ninline MTYPE _equal(MTYPE x, MTYPE y) {\n return x == y;\n}\n\ninline MTYPE _notEqual(MTYPE x, MTYPE y) {\n return x != y;\n}\n\n#endif /* MATRIX_FUNCS_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/util/include/queue.h", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef QUEUE_H_\n#define QUEUE_H_\n#include \n#include \n\n/*\n * A thread-safe circular queue that automatically grows but never shrinks.\n */\ntemplate \nclass Queue {\nprivate:\n T *_elements;\n int _numElements;\n int _head, _tail;\n int _maxSize;\n pthread_mutex_t *_queueMutex;\n pthread_cond_t *_queueCV;\n\n void _init(int initialSize) {\n _numElements = 0;\n _head = 0;\n _tail = 0;\n _maxSize = initialSize;\n _elements = new T[initialSize];\n _queueCV = (pthread_cond_t*)(malloc(sizeof (pthread_cond_t)));\n _queueMutex = (pthread_mutex_t*)(malloc(sizeof (pthread_mutex_t)));\n pthread_mutex_init(_queueMutex, NULL);\n pthread_cond_init(_queueCV, NULL);\n }\n\n void expand() {\n T *newStorage = new T[_maxSize * 2];\n memcpy(newStorage, _elements + _head, (_maxSize - _head) * sizeof(T));\n memcpy(newStorage + _maxSize - _head, _elements, _tail * sizeof(T));\n delete[] _elements;\n _elements = newStorage;\n _head = 0;\n _tail = _numElements;\n _maxSize *= 2;\n }\npublic:\n Queue(int initialSize) {\n _init(initialSize);\n }\n\n Queue() {\n _init(1);\n }\n\n ~Queue() {\n pthread_mutex_destroy(_queueMutex);\n pthread_cond_destroy(_queueCV);\n delete[] _elements;\n free(_queueMutex);\n free(_queueCV);\n }\n\n void enqueue(T el) {\n pthread_mutex_lock(_queueMutex);\n if (_numElements == _maxSize) {\n expand();\n }\n _elements[_tail] = el;\n _tail = (_tail + 1) % _maxSize;\n _numElements++;\n\n pthread_cond_signal(_queueCV);\n pthread_mutex_unlock(_queueMutex);\n }\n\n /*\n * Blocks until not empty.\n */\n T dequeue() {\n pthread_mutex_lock(_queueMutex);\n // Apparently, pthread_cond_signal may actually unblock\n // multiple threads, so a while loop is needed here.\n while (_numElements == 0) {\n pthread_cond_wait(_queueCV, _queueMutex);\n }\n T el = _elements[_head];\n _head = (_head + 1) % _maxSize;\n _numElements--;\n pthread_mutex_unlock(_queueMutex);\n return el;\n }\n\n /*\n * Obviously this number can change by the time you actually look at it.\n */\n inline int getNumElements() const {\n return _numElements;\n }\n};\n\n#endif /* QUEUE_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/util/include/sync.h", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef SYNC_H_\n#define SYNC_H_\n\n#include \n\nclass Lock {\nprivate: \n pthread_mutex_t _mutex;\npublic:\n Lock() {\n pthread_mutex_init(&_mutex, NULL);\n }\n ~Lock() {\n pthread_mutex_destroy(&_mutex);\n }\n \n void acquire() {\n pthread_mutex_lock(&_mutex);\n }\n \n void release() {\n pthread_mutex_unlock(&_mutex);\n }\n};\n\nclass ThreadSynchronizer {\nprivate:\n int _numThreads;\n int _numSynced;\n pthread_mutex_t *_syncMutex;\n pthread_cond_t *_syncThresholdCV;\npublic:\n ThreadSynchronizer(int numThreads) {\n _numThreads = numThreads;\n _numSynced = 0;\n _syncMutex = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));\n _syncThresholdCV = (pthread_cond_t*) malloc(sizeof(pthread_cond_t));\n pthread_mutex_init(_syncMutex, NULL);\n pthread_cond_init(_syncThresholdCV, NULL);\n }\n\n ~ThreadSynchronizer() {\n pthread_mutex_destroy(_syncMutex);\n pthread_cond_destroy(_syncThresholdCV);\n free(_syncMutex);\n free(_syncThresholdCV);\n }\n\n void sync() {\n pthread_mutex_lock(_syncMutex);\n _numSynced++;\n\n if (_numSynced == _numThreads) {\n _numSynced = 0;\n pthread_cond_broadcast(_syncThresholdCV);\n } else {\n pthread_cond_wait(_syncThresholdCV, _syncMutex);\n }\n pthread_mutex_unlock(_syncMutex);\n }\n};\n\n#endif /* SYNC_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/util/include/thread.h", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef THREAD_H_\n#define THREAD_H_\n#include \n#include \n#include \n#include \n#include \n\n#define NUM_CPUS_MAX 48\n\n/*\n * Abstract joinable thread class.\n * The only thing the implementer has to fill in is the run method.\n */\nclass Thread {\nprivate:\n cpu_set_t *_cpu_set;\n pthread_attr_t _pthread_attr;\n pthread_t _threadID;\n bool _joinable, _startable;\n\n static void* start_pthread_func(void *obj) {\n void* retval = reinterpret_cast(obj)->run();\n pthread_exit(retval);\n return retval;\n }\nprotected:\n virtual void* run() = 0;\npublic:\n Thread(bool joinable) : _cpu_set(NULL), _joinable(joinable), _startable(true) {\n pthread_attr_init(&_pthread_attr);\n }\n\n Thread(bool joinable, std::vector& cpus) : _cpu_set(NULL), _joinable(joinable), _startable(true) {\n pthread_attr_init(&_pthread_attr);\n setAffinity(cpus);\n }\n\n virtual ~Thread() {\n if (_cpu_set != NULL) {\n CPU_FREE(_cpu_set);\n }\n pthread_attr_destroy(&_pthread_attr);\n }\n\n void setAffinity(std::vector& cpus) {\n assert(_startable);\n _cpu_set = CPU_ALLOC(NUM_CPUS_MAX);\n size_t size = CPU_ALLOC_SIZE(NUM_CPUS_MAX);\n if (cpus.size() > 0 && cpus[0] >= 0) {\n CPU_ZERO_S(size, _cpu_set);\n for (int i = 0; i < cpus.size(); i++) {\n assert(cpus[i] < NUM_CPUS_MAX);\n CPU_SET_S(cpus[i], size, _cpu_set);\n// printf(\"set cpu %d\\n\", cpus[i]);\n }\n pthread_attr_setaffinity_np(&_pthread_attr, size, _cpu_set);\n }\n }\n\n pthread_t start() {\n assert(_startable);\n _startable = false;\n pthread_attr_setdetachstate(&_pthread_attr, _joinable ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED);\n int n;\n if ((n = pthread_create(&_threadID, &_pthread_attr, &Thread::start_pthread_func, (void*)this))) {\n errno = n;\n perror(\"pthread_create error\");\n }\n return _threadID;\n }\n\n void join(void **status) {\n assert(_joinable);\n int n;\n if((n = pthread_join(_threadID, status))) {\n errno = n;\n perror(\"pthread_join error\");\n }\n }\n\n void join() {\n join(NULL);\n }\n\n pthread_t getThreadID() const {\n return _threadID;\n }\n\n bool isStartable() const {\n return _startable;\n }\n};\n\n#endif /* THREAD_H_ */\n" }, { "path": "caffe2/contrib/cuda-convnet2/util/src/matrix.cpp", "content": "/*\n * Copyright 2014 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"../include/matrix.h\"\n#include \"../include/matrix_funcs.h\"\n\n#if defined(_WIN64) || defined(_WIN32)\ndouble sqrt(int _X) {return sqrt((double) _X);}\ndouble log(int _X) {return log((double) _X);}\n#endif\n\nusing namespace std;\n\nvoid Matrix::_init(MTYPE* data, int64 numRows, int64 numCols, bool transpose, bool ownsData) {\n _updateDims(numRows, numCols);\n _ownsData = ownsData;\n _trans = transpose ? CblasTrans : CblasNoTrans;\n _data = data;\n}\n\nMatrix::Matrix() {\n _init(NULL, 0, 0, false, true);\n}\n\nMatrix::Matrix(int64 numRows, int64 numCols) {\n _init(NULL, numRows, numCols, false, true);\n this->_data = numRows * numCols > 0 ? new MTYPE[this->_numElements] : NULL;\n}\n\nMatrix::Matrix(int64 numRows, int64 numCols, bool transpose) {\n _init(NULL, numRows, numCols, transpose, true);\n this->_data = numRows * numCols > 0 ? new MTYPE[this->_numElements] : NULL;\n}\n\nMatrix::Matrix(const Matrix &like) {\n _init(NULL, like.getNumRows(), like.getNumCols(), false, true);\n this->_data = new MTYPE[this->_numElements];\n}\n\n/* construct a matrix with another matrix's data. the resultant\n * matrix does NOT own its data */\nMatrix::Matrix(MTYPE* data, int64 numRows, int64 numCols) {\n _init(data, numRows, numCols, false, false);\n}\n\n/* construct a matrix with another matrix's data (and optionally transpose it). the resultant\n * matrix does NOT own its data -- it is a VIEW */\nMatrix::Matrix(MTYPE* data, int64 numRows, int64 numCols, bool transpose) {\n _init(data, numRows, numCols, transpose, false);\n}\n\n#ifdef NUMPY_INTERFACE\nMatrix::Matrix(const PyArrayObject *src) {\n this->_data = NULL;\n this->_trans = CblasNoTrans;\n if (src != NULL) {\n this->_updateDims(PyArray_DIM(src,0), PyArray_DIM(src,1));\n if (src->flags & NPY_CONTIGUOUS || src->flags & NPY_FORTRAN) {\n this->_data = (MTYPE*) src->data;\n this->_ownsData = false;\n this->_trans = src->flags & NPY_CONTIGUOUS ? CblasNoTrans : CblasTrans;\n } else {\n this->_data = new MTYPE[PyArray_DIM(src,0) * PyArray_DIM(src,1)];\n for (int64 i = 0; i < PyArray_DIM(src,0); i++) {\n for (int64 j = 0; j < PyArray_DIM(src,1); j++) {\n (*this)(i,j) = *reinterpret_cast(PyArray_GETPTR2(src,i,j));\n }\n }\n this->_ownsData = true;\n }\n }\n}\n#endif\nMatrix::~Matrix() {\n if(this->_data != NULL && this->_ownsData) {\n delete[] this->_data;\n }\n}\n\nvoid Matrix::_updateDims(int64 numRows, int64 numCols) {\n this->_numRows = numRows;\n this->_numCols = numCols;\n this->_numElements = numRows * numCols;\n}\n\nvoid Matrix::_checkBounds(int64 startRow, int64 endRow, int64 startCol, int64 endCol) const {\n assert(startRow >= 0 && startRow <= _numRows);\n assert(endRow >= 0 && endRow <= _numRows);\n assert(startCol >= 0 && startCol <= _numCols);\n assert(endCol >= 0 && endCol <= _numCols);\n}\n\n/* will return a view if possible */\nMatrix& Matrix::slice(int64 startRow, int64 endRow, int64 startCol, int64 endCol) const {\n endRow = endRow < 0 ? this->_numRows : endRow;\n endCol = endCol < 0 ? this->_numCols : endCol;\n _checkBounds(startRow, endRow, startCol, endCol);\n if (!isTrans() && ((startCol == 0 && endCol == this->_numCols) || (startRow == endRow - 1))) {\n return *new Matrix(this->_data + startRow * this->_numCols + startCol, endRow - startRow, endCol - startCol);\n } else if (isTrans() && ((startRow == 0 && endRow == this->_numRows) || (startCol == endCol - 1))) {\n return *new Matrix(this->_data + startCol * this->_numRows + startRow, endRow - startRow, endCol - startCol, true);\n }\n Matrix& newSlice = *new Matrix(endRow - startRow, endCol - startCol);\n this->copy(newSlice, startRow, endRow, startCol, endCol, 0, 0);\n return newSlice;\n}\n\n/* this will NEVER return a view, unlike Matrix_slice */\nvoid Matrix::slice(int64 startRow, int64 endRow, int64 startCol, int64 endCol, Matrix& target) const {\n endRow = endRow < 0 ? this->_numRows : endRow;\n endCol = endCol < 0 ? this->_numCols : endCol;\n _checkBounds(startRow, endRow, startCol, endCol);\n target.resize(endRow - startRow, endCol - startCol);\n this->copy(target, startRow, endRow, startCol, endCol, 0, 0);\n}\n\nMatrix& Matrix::sliceRows(int64 startRow, int64 endRow) const {\n return slice(startRow, endRow, 0, -1);\n}\n\nvoid Matrix::sliceRows(int64 startRow, int64 endRow, Matrix& target) const {\n slice(startRow, endRow, 0, -1, target);\n}\n\nMatrix& Matrix::sliceCols(int64 startCol, int64 endCol) const {\n return slice(0, -1, startCol, endCol);\n}\n\nvoid Matrix::sliceCols(int64 startCol, int64 endCol, Matrix& target) const {\n slice(0, -1, startCol, endCol, target);\n}\n\nvoid Matrix::subtractFromScalar(MTYPE scalar) {\n subtractFromScalar(scalar, *this);\n}\n\nvoid Matrix::subtractFromScalar(MTYPE scalar, Matrix& target) const {\n if(&target != this) {\n copy(target);\n }\n target.scale(-1);\n target.addScalar(scalar);\n}\n\nvoid Matrix::biggerThanScalar(MTYPE scalar) {\n biggerThanScalar(scalar, *this);\n}\n\nvoid Matrix::smallerThanScalar(MTYPE scalar) {\n smallerThanScalar(scalar, *this);\n}\n\nvoid Matrix::equalsScalar(MTYPE scalar) {\n equalsScalar(scalar, *this);\n}\n\nvoid Matrix::biggerThanScalar(MTYPE scalar, Matrix& target) const {\n target.resize(*this);\n _applyLoopScalar(scalar, &_bigger, target);\n}\n\nvoid Matrix::smallerThanScalar(MTYPE scalar, Matrix& target) const {\n target.resize(*this);\n _applyLoopScalar(scalar, &_smaller, target);\n}\n\nvoid Matrix::equalsScalar(MTYPE scalar, Matrix& target) const {\n target.resize(*this);\n _applyLoopScalar(scalar, &_equal, target);\n}\n\nvoid Matrix::add(const Matrix &m) {\n add(m, 1, *this);\n}\n\nvoid Matrix::add(const Matrix &m, Matrix& target) {\n add(m, 1, target);\n}\n\nvoid Matrix::add(const Matrix &m, MTYPE scale) {\n add(m, scale, *this);\n}\n\nvoid Matrix::subtract(const Matrix &m) {\n add(m, -1, *this);\n}\n\nvoid Matrix::subtract(const Matrix &m, Matrix& target) {\n add(m, -1, target);\n}\n\nvoid Matrix::subtract(const Matrix &m, MTYPE scale) {\n add(m, -scale, *this);\n}\n\nvoid Matrix::subtract(const Matrix &m, MTYPE scale, Matrix& target) {\n add(m, -scale, target);\n}\n\nvoid Matrix::add(const Matrix &m, MTYPE scaleM, Matrix &target) {\n add(m, 1, scaleM, target);\n}\n\nvoid Matrix::add(const Matrix &m, MTYPE scaleThis, MTYPE scaleM) {\n add(m, scaleThis, scaleM, *this);\n}\n\nvoid Matrix::add(const Matrix &m, MTYPE scaleThis, MTYPE scaleM, Matrix &target) {\n assert(this->isSameDims(m));\n if (isTrans() != m.isTrans() || isTrans() != target.isTrans() || scaleThis != 1) {\n if (&target != this) {\n target.resize(*this);\n }\n if(scaleThis == 1 && scaleM == 1) {\n this->_applyLoop2(m, &_add, target);\n } else if (scaleThis == 1) {\n this->_applyLoop2(m, &_addWithScale, scaleM, target);\n } else {\n this->_applyLoop2(m, &_addWithScale2, scaleThis, scaleM, target);\n }\n } else {\n if (&target != this) {\n copy(target);\n }\n CBLAS_AXPY(getNumElements(), scaleM, m._data, 1, target._data, 1);\n }\n}\n\nvoid Matrix::addScalar(MTYPE scalar) {\n addScalar(scalar, *this);\n}\n\nvoid Matrix::addScalar(MTYPE scalar, Matrix& target) const {\n target.resize(*this);\n _applyLoopScalar(scalar, &_add, target);\n}\n\nvoid Matrix::maxWithScalar(MTYPE scalar) {\n maxWithScalar(scalar, *this);\n}\n\nvoid Matrix::maxWithScalar(MTYPE scalar, Matrix& target) const {\n target.resize(*this);\n _applyLoopScalar(scalar, &_max, target);\n}\n\nvoid Matrix::minWithScalar(MTYPE scalar) {\n minWithScalar(scalar, *this);\n}\n\nvoid Matrix::minWithScalar(MTYPE scalar, Matrix& target) const {\n target.resize(*this);\n _applyLoopScalar(scalar, &_min, target);\n}\n\nvoid Matrix::biggerThan(Matrix& a) {\n biggerThan(a, *this);\n}\n\nvoid Matrix::biggerThan(Matrix& a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n _applyLoop2(a, &_bigger, target);\n}\n\nvoid Matrix::smallerThan(Matrix& a) {\n smallerThan(a, *this);\n}\n\nvoid Matrix::smallerThan(Matrix& a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n _applyLoop2(a, &_smaller, target);\n}\n\nvoid Matrix::equals(Matrix& a) {\n equals(a, *this);\n}\n\nvoid Matrix::equals(Matrix& a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n _applyLoop2(a, &_equal, target);\n}\n\nvoid Matrix::notEquals(Matrix& a) {\n notEquals(a, *this);\n}\n\nvoid Matrix::notEquals(Matrix& a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n _applyLoop2(a, &_notEqual, target);\n}\n\nvoid Matrix::minWith(Matrix &a) {\n minWith(a, *this);\n}\n\nvoid Matrix::minWith(Matrix &a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n _applyLoop2(a, &_min, target);\n}\n\nvoid Matrix::maxWith(Matrix &a) {\n maxWith(a, *this);\n}\n\nvoid Matrix::maxWith(Matrix &a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n _applyLoop2(a, &_max, target);\n}\n\n/* this := this + scale*tile(vec) */\nvoid Matrix::addVector(const Matrix& vec, MTYPE scale, Matrix& target) {\n if(&target != this) {\n copy(target);\n }\n assert(std::min(vec.getNumCols(), vec.getNumRows()) == 1);\n const bool rowVector = vec.getNumRows() == 1;\n const bool colVector = vec.getNumCols() == 1;\n assert((rowVector && vec.getNumCols() == target.getNumCols()) || (colVector && vec.getNumRows() == target.getNumRows()));\n if (rowVector && colVector) {\n addScalar(vec(0,0) * scale, target);\n return;\n }\n const int64 loopTil = rowVector ? target.getNumRows() : target.getNumCols();\n const int64 dataInc = ((rowVector && target.isTrans()) || (!rowVector && !target.isTrans())) ? 1 : (rowVector ? target.getNumCols() : target.getNumRows());\n const int64 myStride = ((target.isTrans() && rowVector) || (!target.isTrans() && !rowVector)) ? loopTil : 1;\n for (int64 i = 0; i < loopTil; i++) {\n CBLAS_AXPY(vec.getNumElements(), scale, vec._data, 1, target._data + dataInc * i, myStride);\n }\n}\n\n/* this := this + scale*tile(vec) */\nvoid Matrix::addVector(const Matrix& vec, MTYPE scale) {\n addVector(vec, scale, *this);\n}\n\nvoid Matrix::addVector(const Matrix& vec) {\n addVector(vec, 1, *this);\n}\n\nvoid Matrix::addVector(const Matrix& vec, Matrix& target) {\n addVector(vec, 1, target);\n}\n\nvoid Matrix::eltWiseMultByVector(const Matrix& vec) {\n eltWiseMultByVector(vec, *this);\n}\n\n/* omg test these */\nvoid Matrix::eltWiseMultByVector(const Matrix& vec, Matrix& target) {\n if(&target != this) {\n copy(target);\n }\n assert(std::min(vec.getNumCols(), vec.getNumRows()) == 1);\n const bool rowVector = vec.getNumRows() == 1;\n assert((rowVector && vec.getNumCols() == target.getNumCols()) || (!rowVector && vec.getNumRows() == target.getNumRows()));\n const int64 dataInc = ((rowVector && !target.isTrans()) || (!rowVector && target.isTrans())) ? 1 : (rowVector ? target.getNumRows() : target.getNumCols());\n const int64 myStride = ((!target.isTrans() && !rowVector) || (target.isTrans() && rowVector)) ? 1 : vec.getNumElements();\n const int64 numScaling = rowVector ? target.getNumRows() : target.getNumCols();\n for (int64 i = 0; i < vec.getNumElements(); i++) {\n CBLAS_SCAL(numScaling, vec._data[i], target._data + dataInc * i, myStride);\n }\n}\n\n/* return := scale * this * b */\nvoid Matrix::rightMult(const Matrix& b, MTYPE scale) {\n rightMult(b, scale, *this);\n}\n\n/* return := this * b */\nvoid Matrix::rightMult(const Matrix& b) {\n rightMult(b, 1);\n}\n\n/* target := this * b\n * also resizes target if necessary.*/\nvoid Matrix::rightMult(const Matrix &b, Matrix &target) const {\n rightMult(b, 1, target);\n}\n\n/* target := scaleAB * this * b\n * also resizes target if necessary.*/\nvoid Matrix::rightMult(const Matrix &b, MTYPE scaleAB, Matrix &target) const {\n if(&target != this) {\n target.resize(this->_numRows, b._numCols);\n }\n target.addProduct(*this, b, scaleAB, 0);\n}\n\n/* this := scaleAB * a*b + scaleC * this\n * ALL SIZES MUST BE CORRECT. */\nvoid Matrix::addProduct(const Matrix& a, const Matrix& b, MTYPE scaleAB, MTYPE scaleThis) {\n assert(a.getNumCols() == b.getNumRows());\n assert(this->getNumRows() == a.getNumRows() && this->getNumCols() == b.getNumCols());\n assert(!isTrans());\n CBLAS_GEMM(CblasRowMajor, a._trans, b._trans, a._numRows, b._numCols, a._numCols, scaleAB, a._data,\n a._getNumColsBackEnd(), b._data, b._getNumColsBackEnd(), scaleThis, this->_data, this->_numCols);\n}\n\nvoid Matrix::addProduct(const Matrix& a, const Matrix& b) {\n addProduct(a, b, 1, 1);\n}\n\nMatrix& Matrix::transpose() const {\n return *new Matrix(this->_data, this->_numCols, this->_numRows, !isTrans());\n}\n\nMatrix& Matrix::transpose(bool hard) const {\n if (!hard || isTrans()) {\n return transpose();\n }\n Matrix &meTrans = *new Matrix(_numCols, _numRows);\n for (int64 i = 0; i < _numRows; i++) {\n for (int64 j = 0; j < _numCols; j++) {\n meTrans(j, i) = (*this)(i, j);\n }\n }\n return meTrans;\n}\n\nMatrix& Matrix::tile(int64 timesY, int64 timesX) const {\n Matrix& tiled = *new Matrix(this->_numRows * timesY, this->_numCols * timesX);\n _tileTo2(tiled);\n return tiled;\n}\n\n/* resizes target if necessary */\nvoid Matrix::tile(int64 timesY, int64 timesX, Matrix& target) const {\n target.resize(this->_numRows * timesY, this->_numCols * timesX);\n _tileTo2(target);\n}\n\n/* a variant ... seems to be no faster than original. */\nvoid Matrix::_tileTo2(Matrix& target) const {\n for(int64 y = 0; y < target._numRows; y += this->_numRows) {\n for(int64 x = 0; x < target._numCols; x += this->_numCols) {\n this->copy(target, 0, -1, 0, -1, y, x);\n }\n }\n}\n\n/* guarantees that result will be non-transposed */\nvoid Matrix::resize(int64 newNumRows, int64 newNumCols) {\n if(this->_numRows != newNumRows || this->_numCols != newNumCols) {\n assert(!isView());\n if (this->getNumElements() != newNumRows * newNumCols) {\n delete[] this->_data; //deleting NULL is ok, sez c++\n this->_data = new MTYPE[newNumRows * newNumCols];\n }\n this->_updateDims(newNumRows, newNumCols);\n this->_trans = CblasNoTrans;\n }\n}\n\nvoid Matrix::resize(const Matrix& like) {\n resize(like.getNumRows(), like.getNumCols());\n}\n\nvoid Matrix::scale(MTYPE alpha) {\n scale(alpha, *this);\n}\n\nvoid Matrix::scale(MTYPE alpha, Matrix& target) {\n if (&target != this) {\n target.resize(*this);\n copy(target);\n }\n CBLAS_SCAL(getNumElements(), alpha, target._data, 1);\n}\n\n/* performs no resizing.\n * Warnings:\n * 1. ALL DIMENSIONS MUST BE CORRECT\n * 2. The source and destination memories better not overlap! */\nvoid Matrix::copy(Matrix& dest, int64 srcStartRow, int64 srcEndRow, int64 srcStartCol, int64 srcEndCol, int64 destStartRow, int64 destStartCol) const {\n srcEndRow = srcEndRow < 0 ? this->_numRows : srcEndRow;\n srcEndCol = srcEndCol < 0 ? this->_numCols : srcEndCol;\n assert(destStartRow >= 0 && destStartCol >= 0); //some range-checking\n assert(srcEndRow <= _numRows && srcEndCol <= _numCols);\n assert(destStartRow + srcEndRow - srcStartRow <= dest.getNumRows());\n assert(destStartCol + srcEndCol - srcStartCol <= dest.getNumCols());\n // I found no evidence that memcpy is actually faster than just\n // copying element-by-element.\n if (!isTrans() && !dest.isTrans()) {\n int64 src_start_idx = this->_numCols * srcStartRow + srcStartCol;\n int64 dest_start_idx = dest._numCols * destStartRow + destStartCol;\n int64 copy_row_width = srcEndCol - srcStartCol;\n\n for (int64 i = srcStartRow; i < srcEndRow; i++) {\n memcpy(dest._data + dest_start_idx + dest._numCols * (i - srcStartRow),\n this->_data + src_start_idx + this->_numCols * (i - srcStartRow), sizeof(MTYPE) * copy_row_width);\n }\n } else {\n for (int64 i = srcStartRow; i < srcEndRow; i++) {\n for (int64 j = srcStartCol; j < srcEndCol; j++) {\n dest(i - srcStartRow + destStartRow, j - srcStartCol + destStartCol) = (*this)(i, j);\n }\n }\n }\n}\n\n/* preserves everything excluding transposedness.\n * new matrix owns its data */\nMatrix& Matrix::copy() const {\n Matrix& copy = *new Matrix(*this);\n this->copy(copy);\n return copy;\n}\n\n/* resizes target if necessary */\nvoid Matrix::copy(Matrix& target) const {\n target.resize(this->_numRows, this->_numCols); //target is now non-transposed\n if(this->isTrans() == target.isTrans()) {\n this->_copyAllTo(target);\n } else { //if I'm transposed, make sure that target is non-transposed copy\n this->copy(target, 0, -1, 0, -1, 0, 0);\n }\n}\n\nvoid Matrix::_copyAllTo(Matrix& target) const {\n assert(target.isTrans() == isTrans());\n memcpy((void*) target._data, (void*) this->_data, this->getNumDataBytes());\n target._trans = this->_trans;\n}\n\nMTYPE Matrix::min() const {\n return _aggregate(&_min, MTYPE_MAX);\n}\n\nMatrix& Matrix::min(int64 axis) const {\n Matrix& target = axis == 0 ? *new Matrix(1, this->_numCols) : *new Matrix(this->_numRows, 1);\n this->min(axis, target);\n return target;\n}\n\nvoid Matrix::min(int64 axis, Matrix& target) const {\n _aggregate(axis, target, &_min, MTYPE_MAX);\n}\n\nMTYPE Matrix::max() const {\n return _aggregate(&_max, -MTYPE_MAX);\n}\n\nMatrix& Matrix::max(int64 axis) const {\n Matrix& target = axis == 0 ? *new Matrix(1, this->_numCols) : *new Matrix(this->_numRows, 1);\n this->max(axis, target);\n return target;\n}\n\nvoid Matrix::max(int64 axis, Matrix& target) const {\n _aggregate(axis, target, &_max, -MTYPE_MAX);\n}\n\nMTYPE Matrix::sum() const {\n return _aggregate(&_add, 0);\n}\n\nMTYPE Matrix::norm() const {\n return sqrt(norm2());\n}\n\nMTYPE Matrix::norm2() const {\n return _aggregate(&_addSquare, 0);\n}\n\nMatrix& Matrix::sum(int64 axis) const {\n Matrix& target = axis == 0 ? *new Matrix(1, this->_numCols) : *new Matrix(this->_numRows, 1);\n this->sum(axis, target);\n return target;\n}\n\nvoid Matrix::sum(int64 axis, Matrix& target) const {\n _aggregate(axis, target, &_add, 0);\n}\n\nvoid Matrix::_aggregate(int64 axis, Matrix& target, MTYPE (*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const {\n if (axis == 0) {\n target.resize(1, this->_numCols);\n for (int64 j = 0; j < this->_numCols; j++) {\n target(0, j) = _aggregateCol(j, agg_func, initialValue);\n }\n } else {\n target.resize(this->_numRows, 1);\n for (int64 i = 0; i < this->_numRows; i++) {\n target(i, 0) = _aggregateRow(i, agg_func, initialValue);\n }\n }\n}\n\nMTYPE Matrix::_aggregateRow(int64 row, MTYPE (*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const {\n MTYPE v = initialValue;\n for (int64 j = 0; j < this->_numCols; j++) {\n v = agg_func((*this)(row, j), v);\n }\n return v;\n}\n\nMTYPE Matrix::_aggregateCol(int64 col, MTYPE (*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const {\n MTYPE v = initialValue;\n for (int64 i = 0; i < this->_numRows; i++) {\n v = agg_func((*this)(i, col), v);\n }\n return v;\n}\n\nMTYPE Matrix::_aggregate(MTYPE (*agg_func)(MTYPE, MTYPE), MTYPE initialValue) const {\n MTYPE v = initialValue;\n MTYPE* ptr = _data;\n for (int64 i = 0; i < getNumElements(); i++, ptr++) {\n v = agg_func(*ptr, v);\n }\n return v;\n}\n\nvoid Matrix::printShape(const char* name) const {\n printf(\"%s: %lldx%lld\\n\", name, getNumRows(), getNumCols());\n}\n\nvoid Matrix::print() const {\n print(0,getNumRows(),0, getNumCols());\n}\n\nvoid Matrix::print(int64 rows, int64 cols) const {\n print(0,rows,0, cols);\n}\n\nvoid Matrix::print(int64 startRow, int64 rows, int64 startCol, int64 cols) const {\n for (int64 i = startRow; i < std::min(startRow+rows, this->_numRows); i++) {\n for (int64 j = startCol; j < std::min(startCol+cols, this->_numCols); j++) {\n printf(\"%.15f \", (*this)(i, j));\n }\n printf(\"\\n\");\n }\n}\n\nvoid Matrix::apply(Matrix::FUNCTION f) {\n apply(f, *this);\n}\n\n\nvoid Matrix::apply(Matrix::FUNCTION f, Matrix& target) {\n MTYPE (*func)(MTYPE);\n if(f == EXP) {\n func = &_exp;\n } else if(f == TANH) {\n func = &_tanh;\n } else if(f == RECIPROCAL) {\n func = &_recip;\n } else if (f == SQUARE) {\n func = &_square;\n } else if(f == LOG) {\n func = &_log;\n } else if(f == ZERO) {\n func = &_zero;\n } else if (f == ONE) {\n func = &_one;\n } else if(f == LOGISTIC1) {\n func = &_sigma1;\n } else if(f == LOGISTIC2) {\n func = &_sigma2;\n } else if (f == ABS) {\n func = &_abs;\n } else if (f == SIGN) {\n func = &_sign;\n } else {\n return;\n //LOG(FATAL) << \"Matrix::apply: Unknown function type\";\n }\n this->_applyLoop(func, target);\n}\n\nvoid Matrix::eltWiseMult(const Matrix& a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n this->_applyLoop2(a, &_mult, target);\n}\n\nvoid Matrix::eltWiseDivide(const Matrix& a, Matrix& target) const {\n assert(isSameDims(a));\n target.resize(*this);\n this->_applyLoop2(a, &_divide, target);\n}\n\nvoid Matrix::eltWiseMult(const Matrix& a) {\n eltWiseMult(a, *this);\n}\n\nvoid Matrix::eltWiseDivide(const Matrix& a) {\n eltWiseDivide(a, *this);\n}\n\nvoid Matrix::randomizeUniform() {\n this->_applyLoop(&_rand);\n}\n\nvoid Matrix::randomizeNormal() {\n //LOG(FATAL) << \"randomizeNormal only implemented on MKL!\";\n}\n\nvoid Matrix::randomizeNormal(MTYPE mean, MTYPE stdev) {\n //LOG(FATAL) << \"randomizeNormal only implemented on MKL!\";\n}\n\nvoid Matrix::eltWiseDivideByVector(const Matrix& vec) {\n eltWiseDivideByVector(vec, *this);\n}\n\n/* This function allocates a chunk of memory at most as big as the input vector */\nvoid Matrix::eltWiseDivideByVector(const Matrix& vec, Matrix& target) {\n assert(std::min(vec.getNumCols(), vec.getNumRows()) == 1);\n const bool rowVector = vec.getNumRows() == 1;\n assert((rowVector && vec.getNumCols() == getNumCols()) || (!rowVector && vec.getNumRows() == getNumRows()));\n if(&target != this) {\n target.resize(*this);\n }\n _divideByVector(vec, target);\n}\n\nvoid Matrix::_divideByVector(const Matrix& vec, Matrix& target) {\n Matrix& vecInverse = vec.copy();\n vecInverse.apply(RECIPROCAL);\n eltWiseMultByVector(vecInverse,target);\n delete &vecInverse;\n}\n\nvoid Matrix::reshape(int64 numRows, int64 numCols) {\n assert(_numElements == numRows*numCols);\n _numRows = numRows;\n _numCols = numCols;\n}\n\nMatrix& Matrix::reshaped(int64 numRows, int64 numCols) {\n assert(_numElements == numRows*numCols);\n return *new Matrix(_data, numRows, numCols, isTrans());\n}\n\nvoid Matrix::_applyLoop(MTYPE (*func)(MTYPE), Matrix& target) {\n MTYPE *ptr = this->_data, *tgtPtr = target._data;\n for (int64 i = 0; i < getNumElements(); i++, ptr++, tgtPtr++) {\n *tgtPtr = (*func)(*ptr);\n }\n}\n\nvoid Matrix::_applyLoop(MTYPE (*func)(MTYPE)) {\n _applyLoop(func, *this);\n}\n\nvoid Matrix::_applyLoop2(const Matrix& a, MTYPE (*func)(MTYPE,MTYPE), Matrix& target) const {\n for (int64 i = 0; i < getNumRows(); i++) {\n for (int64 j = 0; j < getNumCols(); j++) {\n target(i, j) = (*func)((*this)(i, j), a(i, j));\n }\n }\n}\n\nvoid Matrix::_applyLoop2(const Matrix& a, MTYPE (*func)(MTYPE,MTYPE, MTYPE), MTYPE scalar, Matrix& target) const {\n for (int64 i = 0; i < getNumRows(); i++) {\n for (int64 j = 0; j < getNumCols(); j++) {\n target(i, j) = (*func)((*this)(i, j), a(i, j), scalar);\n }\n }\n}\n\nvoid Matrix::_applyLoop2(const Matrix& a, MTYPE (*func)(MTYPE,MTYPE, MTYPE, MTYPE), MTYPE scalar1, MTYPE scalar2, Matrix& target) const {\n for (int64 i = 0; i < getNumRows(); i++) {\n for (int64 j = 0; j < getNumCols(); j++) {\n target(i, j) = (*func)((*this)(i, j), a(i, j), scalar1, scalar2);\n }\n }\n}\n\nvoid Matrix::_applyLoopScalar(const MTYPE scalar, MTYPE(*func)(MTYPE, MTYPE), Matrix& target) const {\n MTYPE *myPtr = _data;\n MTYPE *targetPtr = target._data;\n for (int64 i = 0; i < getNumElements(); i++, myPtr++, targetPtr++) {\n *targetPtr = (*func)(*myPtr, scalar);\n }\n}\n\nbool Matrix::hasNan() const {\n for (int64 r = 0; r < _numRows; r++) {\n for (int64 c = 0; c < _numCols; c++) {\n if (isnan((*this)(r,c))) {\n return true;\n }\n }\n }\n return false;\n}\n\nbool Matrix::hasInf() const {\n for (int64 r = 0; r < _numRows; r++) {\n for (int64 c = 0; c < _numCols; c++) {\n if (isinf((*this)(r,c))) {\n return true;\n }\n }\n }\n return false;\n}\n\n\n" }, { "path": "caffe2/contrib/docker-ubuntu-14.04/Dockerfile", "content": "FROM ubuntu:14.04\nMAINTAINER caffe-dev \n\n# A docker container with CUDA and caffe2 installed.\n# Note: this should install everything but cudnn, which requires you to have a\n# manual registration and download from the NVidia website. After creating this\n# docker image, the Caffe2 repository is located at /opt/caffe2. You can install\n# cudnn manually and re-compile caffe2.\n\n################################################################################\n# Step 1: set up cuda on the ubuntu box.\n################################################################################\n\nRUN apt-get update && apt-get install -q -y \\\n build-essential \\\n wget\n\nRUN cd /tmp && \\\n wget http://developer.download.nvidia.com/compute/cuda/7_0/Prod/local_installers/cuda_7.0.28_linux.run && \\\n chmod +x cuda_*_linux.run && ./cuda_*_linux.run -extract=`pwd` && \\\n ./NVIDIA-Linux-x86_64-*.run -s --no-kernel-module && \\\n ./cuda-linux64-rel-*.run -noprompt && \\\n rm -rf *\n\n# Ensure the CUDA libs and binaries are in the correct environment variables\nENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64\nENV PATH=$PATH:/usr/local/cuda/bin\n\n# Run nvcc to make sure things are set correctly.\nRUN nvcc --version\n\n################################################################################\n# Step 2: set up caffe2 pre-requisites\n################################################################################\n\nRUN apt-get update && apt-get install -q -y \\\n git \\\n libeigen3-dev \\\n libgoogle-glog-dev \\\n libleveldb-dev \\\n liblmdb-dev \\\n libopencv-dev \\\n libprotobuf-dev \\\n libsnappy-dev \\\n zlib1g-dev \\\n libbz2-dev \\\n protobuf-compiler \\\n python-dev \\\n python-pip\n\nRUN cd /tmp && \\\n git clone https://github.com/facebook/rocksdb.git && \\\n cd /tmp/rocksdb && \\\n make && make install && \\\n cd / && \\\n rm -rf /tmp/rocksdb\n\n# Caffe2 works best with openmpi 1.8.5 or above (which has cuda support).\n# If you do not need openmpi, skip this step.\nRUN cd /tmp && \\\n wget http://www.open-mpi.org/software/ompi/v1.10/downloads/openmpi-1.10.0.tar.gz && \\\n tar xzvf openmpi-1.10.0.tar.gz && \\\n cd /tmp/openmpi-1.10.0 && \\\n ./configure --with-cuda --with-threads && \\\n make && make install && \\\n cd / && \\\n rm -rf /tmp/openmpi-1.10.0 && \\\n rm /tmp/openmpi-1.10.0.tar.gz\n\n# Caffe2 requires zeromq 4.0 or above, manually install.\n# If you do not need zeromq, skip this step.\nRUN apt-get install -q -y autoconf libtool\nRUN mkdir /tmp/zeromq-build && \\\n cd /tmp/zeromq-build && \\\n wget https://github.com/zeromq/zeromq4-1/archive/v4.1.3.tar.gz && \\\n tar xzvf v4.1.3.tar.gz --strip 1 && \\\n ./autogen.sh && \\\n ./configure --without-libsodium && \\\n make && make install && \\\n cd / && \\\n rm -rf /tmp/zeromq-build\n\n# pip self upgrade\nRUN pip install --upgrade pip\n\n# Python dependencies\nRUN pip install \\\n matplotlib \\\n numpy \\\n protobuf\n\n################################################################################\n# Step 3: install optional dependencies (\"good to have\" features)\n################################################################################\n\nRUN apt-get install -q -y \\\n gfortran \\\n graphviz \\\n libatlas-base-dev \\\n vim\n\nRUN pip install \\\n flask \\\n ipython \\\n notebook \\\n pydot \\\n python-nvd3 \\\n scipy \\\n tornado\n\n# This is intentional. scikit-image has to be after scipy.\nRUN pip install \\\n scikit-image\n\n################################################################################\n# Step 4: set up caffe2\n################################################################################\n\n# Get the repository, and build.\nRUN cd /opt && \\\n git clone https://github.com/Yangqing/caffe2.git && \\\n cd /opt/caffe2 && \\\n make\n\n# Now, we know that some of the caffe tests will fail. How do we deal with\n# those?\n" }, { "path": "caffe2/contrib/gloo/CMakeLists.txt", "content": "if(USE_GLOO)\n set(Caffe2_CONTRIB_GLOO_CPU_SRC\n \"${CMAKE_CURRENT_SOURCE_DIR}/allgather_ops.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/allreduce_ops.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/barrier_ops.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/broadcast_ops.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/common.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/common_world_ops.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/context.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/reduce_scatter_ops.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/store_handler.cc\"\n )\n\n set(Caffe2_CONTRIB_GLOO_GPU_SRC\n \"${CMAKE_CURRENT_SOURCE_DIR}/allreduce_ops_gpu.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/broadcast_ops_gpu.cc\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/common_world_ops_gpu.cc\"\n )\n\n set(Caffe2_CPU_SRCS ${Caffe2_CPU_SRCS} ${Caffe2_CONTRIB_GLOO_CPU_SRC} PARENT_SCOPE)\n set(Caffe2_GPU_SRCS ${Caffe2_GPU_SRCS} ${Caffe2_CONTRIB_GLOO_GPU_SRC} PARENT_SCOPE)\nendif()\n" }, { "path": "caffe2/contrib/gloo/allgather_ops.cc", "content": "/**\n * Copyright (c) 2017-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"allgather_ops.h\"\n\n#include \n\nnamespace caffe2 {\nnamespace gloo {\n\ntemplate \nvoid AllgatherOp::initializeAlgorithm() {\n if (init_.template IsType()) {\n algorithm_.reset(new ::gloo::AllgatherRing(\n init_.context,\n init_.template getInputs(),\n init_.template getOutput(),\n init_.size));\n } else if (init_.template IsType()) {\n algorithm_.reset(new ::gloo::AllgatherRing(\n init_.context,\n init_.template getInputs(),\n init_.template getOutput(),\n init_.size));\n } else if (init_.template IsType()) {\n algorithm_.reset(new ::gloo::AllgatherRing(\n init_.context,\n init_.template getInputs(),\n init_.template getOutput(),\n init_.size));\n } else if (init_.template IsType()) {\n algorithm_.reset(new ::gloo::AllgatherRing<::gloo::float16>(\n init_.context,\n init_.template getInputs<::gloo::float16>(),\n init_.template getOutput<::gloo::float16>(),\n init_.size));\n } else {\n CAFFE_ENFORCE(false, \"Unhandled type: \", init_.meta.name());\n }\n}\n\nnamespace {\n\nREGISTER_CPU_OPERATOR_WITH_ENGINE(Allgather, GLOO, AllgatherOp);\n\n} // namespace\n} // namespace gloo\n} // namespace caffe2\n" }, { "path": "caffe2/contrib/gloo/allgather_ops.h", "content": "/**\n * Copyright (c) 2017-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n\n#include \"caffe2/contrib/gloo/common.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/core/types.h\"\n\n#include \n#include \n#include \n\nnamespace caffe2 {\nnamespace gloo {\n\ntemplate \nclass AllgatherOp final : public Operator {\n public:\n USE_OPERATOR_CONTEXT_FUNCTIONS;\n\n AllgatherOp(const OperatorDef& operator_def, Workspace* ws)\n : Operator(operator_def, ws),\n ws_(ws),\n status_blob_(\n OperatorBase::GetSingleArgument(\"status_blob\", \"\")) {\n if (status_blob_ != \"\") {\n ws_->CreateBlob(status_blob_);\n }\n }\n\n virtual ~AllgatherOp() {}\n\n bool RunOnDevice() override {\n std::call_once(once_, [&] { initialize(); });\n\n // If any parameter has changed in between runs, the initialized\n // algorithm is invalid and cannot be used.\n update(current_);\n CAFFE_ENFORCE(current_ == init_, \"Inputs/outputs have changed\");\n\n try {\n algorithm_->run();\n } catch (::gloo::IoException& ioe) {\n LOG(ERROR) << \"Caught gloo IO exception: \" << ioe.what();\n if (status_blob_ != \"\") {\n signalFailure(ws_->GetBlob(status_blob_), ioe);\n return false;\n } else {\n throw ioe;\n }\n }\n return true;\n }\n\n protected:\n void initialize() {\n // Allocate output tensor\n CAFFE_ENFORCE_EQ(OutputSize(), 1);\n auto comm_size =\n OperatorBase::Input>(0)->size;\n const auto dims =\n std::vector(1, (InputSize() - 1) * Input(1).size() * comm_size);\n Output(0)->Resize(dims);\n\n // Store which inputs/outputs this instance initialized with\n update(init_);\n\n CAFFE_ENFORCE_EQ(init_.outputs.size(), 1);\n\n // Verify tensors all have same size\n size_t size = Input(1).size();\n for (auto i = 2; i < InputSize(); i++) {\n CAFFE_ENFORCE_EQ(Input(i).size(), size);\n }\n\n // Verify tensors all have same type\n TypeMeta meta = Input(1).meta();\n for (auto i = 2; i < InputSize(); i++) {\n CAFFE_ENFORCE(Input(i).meta() == meta);\n }\n\n // Finally initialize the algorithm\n initializeAlgorithm();\n }\n\n void initializeAlgorithm();\n\n std::once_flag once_;\n std::unique_ptr<::gloo::Algorithm> algorithm_;\n\n // Captures the parameters passed to Gloo when first initialized.\n // An instance is updated every time this op runs and is compared\n // to the reference instance for equality. If any parameter has\n // changed from run to run, the initialized algorithm is invalid.\n void update(GlooParameters& params) {\n params.context = OperatorBase::Input>(0);\n params.inputs.resize(InputSize() - 1);\n params.size = Input(1).size();\n params.meta = Input(1).meta();\n for (auto i = 0; i < params.inputs.size(); i++) {\n params.inputs[i] = Input(i + 1).template raw_data();\n }\n params.outputs.resize(OutputSize());\n params.outputs[0] = Output(0)->raw_mutable_data(params.meta);\n }\n\n GlooParameters init_;\n GlooParameters current_;\n Workspace* ws_;\n std::string status_blob_;\n};\n\n} // namespace gloo\n} // namespace caffe2\n" }, { "path": "caffe2/contrib/gloo/allreduce_ops.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"allreduce_ops.h\"\n\n#include \n#include \n#include \n#include \n\nnamespace caffe2 {\nnamespace gloo {\n\ntemplate \nvoid AllreduceOp::initializeHalvingDoubling() {\n if (init_.template IsType()) {\n algorithm_.reset(new ::gloo::AllreduceHalvingDoubling(\n init_.context, init_.template getOutputs(), init_.size));\n } else if (init_.template IsType<::caffe2::float16>()) {\n algorithm_.reset(new ::gloo::AllreduceHalvingDoubling<::gloo::float16>(\n init_.context,\n init_.template getOutputs<::gloo::float16>(),\n init_.size));\n } else {\n CAFFE_ENFORCE(false, \"Unhandled type: \", init_.meta.name());\n }\n}\n\ntemplate \nvoid AllreduceOp::initializeRingFull() {\n if (init_.template IsType()) {\n algorithm_.reset(new ::gloo::AllreduceRing(\n init_.context, init_.template getOutputs(), init_.size));\n } else if (init_.template IsType<::caffe2::float16>()) {\n algorithm_.reset(new ::gloo::AllreduceRing<::gloo::float16>(\n init_.context,\n init_.template getOutputs<::gloo::float16>(),\n init_.size));\n } else {\n CAFFE_ENFORCE(false, \"Unhandled type: \", init_.meta.name());\n }\n}\n\ntemplate \nvoid AllreduceOp::initializeRingChunked() {\n if (init_.template IsType()) {\n algorithm_.reset(new ::gloo::AllreduceRingChunked(\n init_.context, init_.template getOutputs(), init_.size));\n } else if (init_.template IsType<::caffe2::float16>()) {\n algorithm_.reset(new ::gloo::AllreduceRingChunked<::gloo::float16>(\n init_.context,\n init_.template getOutputs<::gloo::float16>(),\n init_.size));\n } else {\n CAFFE_ENFORCE(false, \"Unhandled type: \", init_.meta.name());\n }\n}\n\nnamespace {\n\nREGISTER_CPU_OPERATOR_WITH_ENGINE(Allreduce, GLOO, AllreduceOp);\n\n} // namespace\n} // namespace gloo\n} // namespace caffe2\n" }, { "path": "caffe2/contrib/gloo/allreduce_ops.h", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n\n#include \"caffe2/contrib/gloo/common.h\"\n#include \"caffe2/core/operator.h\"\n#include \"caffe2/utils/math.h\"\n\n#include \n#include \n#include \n\nnamespace caffe2 {\nnamespace gloo {\n\ntemplate \nclass AllreduceOp final : public Operator {\n enum Mode { RING_FULL, RING_CHUNKED, HALVING_DOUBLING };\n\n public:\n USE_OPERATOR_CONTEXT_FUNCTIONS;\n\n AllreduceOp(const OperatorDef& operator_def, Workspace* ws)\n : Operator(operator_def, ws),\n ws_(ws),\n status_blob_(\n OperatorBase::GetSingleArgument(\"status_blob\", \"\")),\n gpu_direct_(\n OperatorBase::GetSingleArgument(\"gpu_direct\", false)) {\n if (status_blob_ != \"\") {\n ws_->CreateBlob(status_blob_);\n }\n }\n\n virtual ~AllreduceOp() {}\n\n bool RunOnDevice() override {\n std::call_once(once_, [&] { initialize(); });\n\n // If any parameter has changed in between runs, the initialized\n // algorithm is invalid and cannot be used.\n update(current_);\n CAFFE_ENFORCE(current_ == init_, \"Inputs/outputs have changed\");\n\n try {\n algorithm_->run();\n } catch (::gloo::IoException& ioe) {\n LOG(ERROR) << \"Caught gloo IO exception: \" << ioe.what();\n if (status_blob_ != \"\") {\n signalFailure(ws_->GetBlob(status_blob_), ioe);\n return false;\n } else {\n throw ioe;\n }\n }\n return true;\n }\n\n protected:\n void initialize() {\n Mode mode = HALVING_DOUBLING;\n auto bytes = Input(1).nbytes();\n\n // Store which inputs/outputs this instance initialized with\n update(init_);\n\n // Verify inputs == ouputs\n CAFFE_ENFORCE_EQ(init_.inputs.size(), init_.outputs.size());\n for (auto i = 0; i < init_.inputs.size(); i++) {\n CAFFE_ENFORCE_EQ(init_.inputs[i], init_.outputs[i]);\n }\n\n // Verify tensors all have same size\n size_t size = Input(1).size();\n for (auto i = 2; i < InputSize(); i++) {\n CAFFE_ENFORCE_EQ(Input(i).size(), size);\n }\n\n // Verify tensors all have same type\n TypeMeta meta = Input(1).meta();\n for (auto i = 2; i < InputSize(); i++) {\n CAFFE_ENFORCE(Input(i).meta() == meta);\n }\n\n switch (mode) {\n case RING_FULL:\n initializeRingFull();\n return;\n case RING_CHUNKED:\n initializeRingChunked();\n return;\n case HALVING_DOUBLING:\n initializeHalvingDoubling();\n return;\n }\n\n CAFFE_ENFORCE(false, \"Unreachable code\");\n }\n\n void initializeHalvingDoubling();\n void initializeRingFull();\n void initializeRingChunked();\n\n std::once_flag once_;\n std::unique_ptr<::gloo::Algorithm> algorithm_;\n\n // Captures the parameters passed to Gloo when first initialized.\n // An instance is updated every time this op runs and is compared\n // to the reference instance for equality. If any parameter has\n // changed from run to run, the initialized algorithm is invalid.\n void update(GlooParameters& params) {\n params.context = OperatorBase::Input>(0);\n params.inputs.resize(InputSize() - 1);\n params.outputs.resize(OutputSize());\n for (auto i = 0; i < params.inputs.size(); i++) {\n params.inputs[i] = Input(i + 1).template raw_data();\n params.outputs[i] = Output(i)->template raw_mutable_data();\n }\n params.size = Output(0)->size();\n params.meta = Output(0)->meta();\n }\n\n GlooParameters init_;\n GlooParameters current_;\n Workspace* ws_;\n std::string status_blob_;\n const bool gpu_direct_;\n};\n\n} // namespace gloo\n} // namespace caffe2\n" }, { "path": "caffe2/contrib/gloo/allreduce_ops_gpu.cc", "content": "/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \"allreduce_ops.h\"\n\n#include \"caffe2/core/context_gpu.h\"\n#include \"caffe2/core/logging.h\"\n\n#include \n#include \n#include \n#include \n\nnamespace caffe2 {\nnamespace gloo {\n\nnamespace {\n\n// Decides on using GPUDirect based on device support.\ntemplate