You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mxnet.apache.org by GitBox <gi...@apache.org> on 2018/09/05 21:31:44 UTC
[GitHub] indhub closed pull request #12388: Installation instructions
consolidation
indhub closed pull request #12388: Installation instructions consolidation
URL: https://github.com/apache/incubator-mxnet/pull/12388
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/docs/_static/js/options.js b/docs/_static/js/options.js
index 87e50b8aa86..b43f3919a31 100644
--- a/docs/_static/js/options.js
+++ b/docs/_static/js/options.js
@@ -8,7 +8,7 @@ $(document).ready(function () {
function label(lbl) {
return lbl.replace(/[ .]/g, '-').toLowerCase();
}
-
+
function urlSearchParams(searchString) {
let urlDict = new Map();
let searchParams = searchString.substring(1).split("&");
@@ -45,11 +45,11 @@ $(document).ready(function () {
showContent();
if (window.location.href.indexOf("/install/index.html") >= 0) {
if (versionSelect.indexOf(defaultVersion) >= 0) {
- history.pushState(null, null, '/install/index.html?platform=' + platformSelect + '&language=' + languageSelect + '&processor=' + processorSelect);
+ history.pushState(null, null, 'index.html?platform=' + platformSelect + '&language=' + languageSelect + '&processor=' + processorSelect);
} else {
- history.pushState(null, null, '/install/index.html?version=' + versionSelect + '&platform=' + platformSelect + '&language=' + languageSelect + '&processor=' + processorSelect);
+ history.pushState(null, null, 'index.html?version=' + versionSelect + '&platform=' + platformSelect + '&language=' + languageSelect + '&processor=' + processorSelect);
}
- }
+ }
}
function showContent() {
@@ -73,22 +73,22 @@ $(document).ready(function () {
$('.current-version').html( $(this).text() + ' <span class="caret"></span></button>' );
if ($(this).text().indexOf(defaultVersion) < 0) {
if (window.location.search.indexOf("version") < 0) {
- history.pushState(null, null, '/install/index.html' + window.location.search.concat( '&version=' + $(this).text() ));
+ history.pushState(null, null, 'index.html' + window.location.search.concat( '&version=' + $(this).text() ));
} else {
- history.pushState(null, null, '/install/index.html' + window.location.search.replace( urlParams.get('version'), $(this).text() ));
+ history.pushState(null, null, 'index.html' + window.location.search.replace( urlParams.get('version'), $(this).text() ));
}
} else if (window.location.search.indexOf("version") >= 0) {
- history.pushState(null, null, '/install/index.html' + window.location.search.replace( 'version', 'prev' ));
+ history.pushState(null, null, 'index.html' + window.location.search.replace( 'version', 'prev' ));
}
}
else if ($(this).hasClass("platforms")) {
- history.pushState(null, null, '/install/index.html' + window.location.search.replace( urlParams.get('platform'), $(this).text() ));
+ history.pushState(null, null, 'index.html' + window.location.search.replace( urlParams.get('platform'), $(this).text() ));
}
else if ($(this).hasClass("languages")) {
- history.pushState(null, null, '/install/index.html' + window.location.search.replace( urlParams.get('language'), $(this).text() ));
+ history.pushState(null, null, 'index.html' + window.location.search.replace( urlParams.get('language'), $(this).text() ));
}
else if ($(this).hasClass("processors")) {
- history.pushState(null, null, '/install/index.html' + window.location.search.replace( urlParams.get('processor'), $(this).text() ));
+ history.pushState(null, null, 'index.html' + window.location.search.replace( urlParams.get('processor'), $(this).text() ));
}
showContent();
//window.location.search = window.location.search.replace( urlParams.get('version'), $(this).text() );
diff --git a/docs/install/build_from_source.md b/docs/install/build_from_source.md
index b22ff8833e9..6c0a4dab251 100644
--- a/docs/install/build_from_source.md
+++ b/docs/install/build_from_source.md
@@ -1,22 +1,23 @@
# Build MXNet from Source
-**NOTE:** For MXNet with Python installation, please refer to the [new install guide](http://mxnet.io/install/index.html).
-
-This document explains how to build MXNet from sources. Building MXNet from sources is a 2 step process.
+This document explains how to build MXNet from source code. Building MXNet from source is a two step process.
1. Build the MXNet shared library, `libmxnet.so`, from [C++ source files](#build-the-shared-library)
-2. Install the language binding for MXNet. MXNet supports -
- [C++](#build-the-c-package),
- [Scala](#build-the-scala-package), [R](#build-the-r-package), and
- [Julia](#build-the-julia-package).
+2. Install the [language bindings](#installing-mxnet-language-bindings) for MXNet. MXNet supports the following languages:
+ - Python
+ - C++
+ - Clojure
+ - Julia
+ - Perl
+ - R
+ - Scala
-## Build the shared library
+## Prerequisites
-### Prerequisites
+You need C++ build tools and a BLAS library to build the MXNet shared library. If you want to run MXNet with GPUs, you will need to install [NVDIA CUDA and cuDNN](https://developer.nvidia.com/cuda-downloads) first.
-You need C++ build tools and BLAS library to build MXNet shared library. If you want to run MXNet on GPUs, you need to install CUDA and CuDNN.
-#### C++ build tools
+### C++ build tools
1. A C++ compiler that supports C++ 11.
[G++ (4.8 or later)](https://gcc.gnu.org/gcc-4.8/) or
@@ -24,311 +25,138 @@ You need C++ build tools and BLAS library to build MXNet shared library. If you
2. [Git](https://git-scm.com/downloads) for downloading the sources from Github repository.
-3. [GNU Make](https://www.gnu.org/software/make/) ([cmake](https://cmake.org/)
- for Windows) to build the library.
-
-
-Select your preferences and follow the instructions to install MXNet from sources.
-<div class="btn-group opt-group" role="group">
-<button type="button" class="btn btn-default opt active">Linux</button>
-<button type="button" class="btn btn-default opt">macOS</button>
-<button type="button" class="btn btn-default opt">Windows</button>
-</div>
-<script type="text/javascript" src='../../_static/js/options.js'></script>
-
-<div class="linux">
-
-Then select the Linux distribution:
-<div class="btn-group opt-group" role="group">
-<button type="button" class="btn btn-default opt active">Ubuntu</button>
-<button type="button" class="btn btn-default opt">CentOS</button>
-<button type="button" class="btn btn-default opt">Others</button>
-</div>
-
-- **Ubuntu** for systems supporting the `apt-get`
- package management program
-- **CentOS** for systems supporting the `yum` package
- management program
-- **Others** for general Linux-like systems building dependencies from scratch.
-
-<div class="ubuntu">
-
-Install build tools and git on `Ubuntu >= 13.10` and `Debian >= 8`.
-
-```bash
-sudo apt-get update && sudo apt-get install build-essential git
-```
-
-</div>
-
-<div class="centos">
-
-Install build tools and git on `CentOS >= 7` and `Fedora >= 19`.
-
-```bash
-sudo yum groupinstall -y "Development Tools" && sudo yum install -y git
-```
-
-</div>
-
-<div class="others">
-
-Installing both `git` and `make` by following instructions on the websites is
-straightforward. Here we provide the instructions to build `gcc-4.8` from source codes.
-
-1. Install the 32-bit `libc` with one of the following system-specific commands:
-
- ```bash
- sudo apt-get install libc6-dev-i386 # In Ubuntu
- sudo yum install glibc-devel.i686 # In RHEL (Red Hat Linux)
- sudo yum install glibc-devel.i386 # In CentOS 5.8
- sudo yum install glibc-devel.i686 # In CentOS 6/7
- ```
-
-2. Download and extract the `gcc` source code with the prerequisites:
-
- ```bash
- wget http://mirrors.concertpass.com/gcc/releases/gcc-4.8.5/gcc-4.8.5.tar.gz
- tar -zxf gcc-4.8.5.tar.gz
- cd gcc-4.8.5
- ./contrib/download_prerequisites
- ```
-
-3. Build `gcc` by using 10 threads and then install to `/usr/local`
-
- ```bash
- mkdir release && cd release
- ../configure --prefix=/usr/local --enable-languages=c,c++
- make -j10
- sudo make install
- ```
-
-4. Add the lib path to your configure file such as `~/.bashrc`:
-
- ```bash
- export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/lib64
- ```
+3. [cmake](https://cmake.org/) is recommended. You may also use [GNU Make](https://www.gnu.org/software/make/) to build the library.
-</div>
-</div> <!-- linux -->
-<div class="windows">
-
-1. If [Microsoft Visual Studio 2015](https://www.visualstudio.com/downloads/) is not already installed, download and install it. You can download and install the free community edition.
-2. Download and Install [CMake](https://cmake.org/) if it is not already installed.
-
-</div>
-
-<div class="macos">
-
-Install [Xcode](https://developer.apple.com/xcode/).
-
-</div>
-
-#### BLAS library
+### BLAS library
MXNet relies on the
[BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) (Basic
-Linear Algebra Subprograms) library for numerical computations. You can install
-any one among [ATLAS](http://math-atlas.sourceforge.net/),
-[OpenBLAS](http://www.openblas.net/) and
-[MKL](https://software.intel.com/en-us/intel-mkl).
-
-<div class="linux">
-<div class="ubuntu">
+Linear Algebra Subprograms) library for numerical computations.
+Those can be extended with [LAPACK (Linear Algebra Package)](https://github.com/Reference-LAPACK/lapack), an additional set of mathematical functions.
-```bash
-sudo apt-get install libatlas-base-dev
-```
+MXNet supports multiple mathematical backends for computations on the CPU:
-</div>
+* [Apple Accelerate](https://developer.apple.com/documentation/accelerate)
+* [ATLAS](http://math-atlas.sourceforge.net/)
+* [MKL](https://software.intel.com/en-us/intel-mkl) (MKL, MKLML)
+* [MKLDNN](https://github.com/intel/mkl-dnn)
+* [OpenBLAS](http://www.openblas.net/)
-<div class="centos">
+Usage of these are covered in more detail in the [build configurations](#build-configurations) section.
-```bash
-sudo yum install atlas-devel
-```
-</div>
+### Optional
-<div class="linux">
+These might be optional, but they're typically desirable.
-You can follow this link to build
-[OpenBlas from source](https://github.com/xianyi/OpenBLAS#installation-from-source).
+* [OpenCV](http://opencv.org/) for Image Loading and Augmentation
+* [NVDIA CUDA and cuDNN](https://developer.nvidia.com/cuda-downloads) for running MXNet with GPUs
-</div>
-</div>
-<div class="macos">
+## Build Instructions by Operating System
-macOS users can skip this step as `xcode` ships with a BLAS library.
+Detailed instructions are provided per operating system.
+You may jump to those, but it is recommended that you continue reading to understand more general build from source options.
-</div>
+| | | | |
+|---|---|---|---|
+| [macOS](osx_setup.html) | [Ubuntu](ubuntu_setup.html) | [CentOS/*unix](centos_setup.html) | [Windows](windows_setup.html) |
+| [raspbian](raspian_setup.html) | [tx2](tx2_setup.html) | | |
-<div class="windows">
-1. Download pre-built binaries for [OpenBLAS](https://sourceforge.net/projects/openblas/files/)
-2. Set the environment variable `OpenBLAS_HOME` to point to the OpenBLAS
- directory that contains the `include/` and `lib/` directories. Typically, you
- can find the directory in `C:\Program files (x86)\OpenBLAS\`.
-</div>
-
-#### Optional: [OpenCV](http://opencv.org/) for Image Loading and Augmentation
-
-<div class="linux">
-<div class="ubuntu">
+## Build
+1. Clone the MXNet project.
```bash
-sudo apt-get install libopencv-dev
-```
-
-</div>
-
-<div class="centos">
-
-```bash
-sudo apt-get install opencv-devel
+git clone --recursive https://github.com/apache/incubator-mxnet mxnet
+cd mxnet
```
-</div>
-
-<div class="others">
-
-To build OpenCV from source code, you need the [cmake](https://cmake.org) library.
-
-1. If you don't have cmake or if your version of cmake is earlier than 3.6.1, run the following commands to install a newer version of cmake:
-
- ```bash
- wget https://cmake.org/files/v3.6/cmake-3.6.1-Linux-x86_64.tar.gz
- tar -zxvf cmake-3.6.1-Linux-x86_64.tar.gz
- alias cmake="cmake-3.6.1-Linux-x86_64/bin/cmake"
- ```
-
-2. To download and extract the OpenCV source code, run the following commands:
-
- ```bash
- wget https://codeload.github.com/opencv/opencv/zip/2.4.13
- unzip 2.4.13
- cd opencv-2.4.13
- mkdir release
- cd release/
- ```
-
-3. Build OpenCV. The following commands build OpenCV with 10 threads. We
- disabled GPU support, which might significantly slow down an MXNet program
- running on a GPU processor. It also disables 1394 which might generate a
- warning. Then install it on `/usr/local`.
-
- ```bash
- cmake -D BUILD_opencv_gpu=OFF -D WITH_CUDA=OFF -D WITH_1394=OFF -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local ..
- make -j10
- sudo make install
- ```
+There is a configuration file for make,
+[`make/config.mk`](https://github.com/apache/incubator-mxnet/blob/master/make/config.mk), that contains all the compilation options. You can edit it and then run `make`.
-4. Add the lib path to your configuration such as `~/.bashrc`.
- ```bash
- export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig/
- ```
+## Build Configurations
-</div>
-</div>
+`cmake` is recommended for building MXNet, however you may use `make` instead.
-<div class="windows">
-First download and install [OpenCV](http://opencv.org/releases.html), then set
-the environment variable `OpenCV_DIR` to point to the OpenCV build directory.
+### Math Library Selection
+It is useful to consider your math library selection first.
-</div>
+The default order of choice for the libraries if found follows the path from the most
+(recommended) to less performant backends.
+The following lists show this order by library and `cmake` switch.
-#### Optional: [CUDA](https://developer.nvidia.com/cuda-downloads)/[cuDNN](https://developer.nvidia.com/cudnn) for Nvidia GPUs
+For desktop platforms (x86_64):
-MXNet is compatible with both CUDA 7.5 and 8.0. It is recommended to use cuDNN 5.
+1. MKLDNN (submodule) | `USE_MKLDNN`
+2. MKL | `USE_MKL_IF_AVAILABLE`
+3. MKLML (downloaded) | `USE_MKLML`
+4. Apple Accelerate | `USE_APPLE_ACCELERATE_IF_AVAILABLE` | Mac only
+5. OpenBLAS | `BLAS` | Options: Atlas, Open, MKL, Apple
-<div class="linux">
-<div class="ubuntu">
+Note: If `USE_MKL_IF_AVAILABLE` is set to False then MKLML and MKLDNN will be disabled as well for configuration
+backwards compatibility.
-Install CUDA 7.5 and cuDNN 5 on Ubuntu 14.04
+For embedded platforms (all other and if cross compiled):
-```bash
-wget http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1404/x86_64/cuda-repo-ubuntu1404_7.5-18_amd64.deb
-sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb
-echo "deb http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1404/x86_64 /" | sudo tee /etc/apt/sources.list.d/nvidia-ml.list
-sudo apt-get update
-sudo apt-get install -y linux-image-extra-`uname -r` linux-headers-`uname -r` linux-image-`uname -r`
-sudo apt-get install -y cuda libcudnn5-dev=5.0.5-1+cuda7.5
-```
-
-</div>
-</div>
-
-### Build
-
-<div class="linux macos">
-
-First clone the recent codes
-
-```bash
-git clone --recursive https://github.com/dmlc/mxnet
-cd mxnet
-```
-
-File
-[`make/config.mk`](https://github.com/dmlc/mxnet/blob/master/make/config.mk)
-contains all the compilation options. You can edit it and then `make`. There are
-some example build options
-
-If you want to build MXNet with C++ language binding, please make sure you read [Build the C++ package](#build-the-c-package) first.
-
-</div>
-
-<div class="linux">
+1. OpenBLAS | `BLAS` | Options: Atlas, Open, MKL, Apple
-- Build without using OpenCV. `-j` runs multiple jobs against multi-core CPUs.
+You can set the BLAS library explicitly by setting the BLAS variable to:
- ```bash
- make -j USE_OPENCV=0
- ```
+* Atlas
+* Open
+* MKL
+* Apple
-- Build with both GPU and OpenCV support
+See the [cmake/ChooseBLAS.cmake](https://github.com/apache/incubator-mxnet/blob/master/cmake/ChooseBlas.cmake) file for the options.
- ```bash
- make -j USE_BLAS=openblas USE_CUDA=1 USE_CUDA_PATH=/usr/local/cuda USE_CUDNN=1
- ```
+Intel's MKL (Math Kernel Library) is one of the most powerful math libraries
+https://software.intel.com/en-us/mkl
-</div>
+It has following flavors:
-<div class="macos">
+* MKL is a complete math library, containing all the functionality found in ATLAS, OpenBlas and LAPACK. It is free under
+ community support licensing (https://software.intel.com/en-us/articles/free-mkl),
+ but needs to be downloaded and installed manually.
-- Build with the default BLAS library and clang installed with `xcode` (OPENMP
- is disabled because it is not supported in default by clang).
+* MKLML is a subset of MKL. It contains a smaller number of functions to reduce the
+ size of the download and reduce the number of dynamic libraries user needs.
- ```bash
- make -j USE_BLAS=apple USE_OPENCV=0 USE_OPENMP=0
- ```
+ <!-- [Removed until #11148 is merged.] This is the most effective option since it can be downloaded and installed automatically
+ by the cmake script (see cmake/DownloadMKLML.cmake).-->
-</div>
+* MKLDNN is a separate open-source library, it can be used separately from MKL or MKLML. It is
+ shipped as a subrepo with MXNet source code (see 3rdparty/mkldnn or the [mkl-dnn project](https://github.com/intel/mkl-dnn))
-<div class="windows">
+Since the full MKL library is almost always faster than any other BLAS library it's turned on by default,
+however it needs to be downloaded and installed manually before doing `cmake` configuration.
+Register and download on the [Intel performance libraries website](https://software.seek.intel.com/performance-libraries).
-Use [CMake](https://cmake.org/) to create a Visual Studio solution in ```./build```.
+Note: MKL is supported only for desktop builds and the framework itself supports the following
+hardware:
-In Visual Studio, open the solution file,```.sln```, and compile it.
-These commands produce a library called ```mxnet.dll``` in the ```./build/Release/``` or ```./build/Debug``` folder.
+* Intel® Xeon Phi™ processor
+* Intel® Xeon® processor
+* Intel® Core™ processor family
+* Intel Atom® processor
-</div>
+If you have a different processor you can still try to use MKL, but performance results are
+unpredictable.
-<div class="linux ubuntu">
-## Build MXNet using NCCL
+### Build MXNet with NCCL
- Download and install the latest NCCL library from NVIDIA.
- Note the directory path in which NCCL libraries and header files are installed.
- Ensure that the installation directory contains ```lib``` and ```include``` folders.
-- Ensure that the prerequisites for using NCCL such as Cuda libraries are met.
+- Ensure that the prerequisites for using NCCL such as Cuda libraries are met.
- Append the ```config.mk``` file with following, in addition to the CUDA related options.
- USE_NCCL=1
- USE_NCCL_PATH=path-to-nccl-installation-folder
+
``` bash
echo "USE_NCCL=1" >> make/config.mk
echo "USE_NCCP_PATH=path-to-nccl-installation-folder" >> make/config.mk
@@ -339,7 +167,7 @@ cp make/config.mk .
make -j"$(nproc)"
```
-## Validation
+#### Validating NCCL
- Follow the steps to install MXNet Python binding.
- Comment the following line in ```test_nccl.py``` file at ```incubator-mxnet/tests/python/gpu/test_nccl.py```
``` bash
@@ -350,143 +178,56 @@ make -j"$(nproc)"
nosetests --verbose tests/python/gpu/test_nccl.py
```
-## Recommendation for best performance
+**Recommendation to get the best performance out of NCCL:**
It is recommended to set environment variable NCCL_LAUNCH_MODE to PARALLEL when using NCCL version 2.1 or newer.
-</div>
-
-## Build the C++ package
-The C++ package has the same prerequisites as the MXNet library, you should also have `python` installed. (Both `python` 2 and 3 are supported)
-
-To enable C++ package, just add `USE_CPP_PACKAGE=1` in the build options when building the MXNet shared library.
-
-## Build the R package
+### Build MXNet with Language Packages
+* To enable C++ package, just add `USE_CPP_PACKAGE=1` when you run `make` or `cmake`.
-The R package requires `R` to be installed.
-<div class="ubuntu">
-
-Follow the below instructions to install the latest R on Ubuntu 14.04 (trusty) and also the libraries used
-to build other R package dependencies.
+### Usage Examples
+* `-j` runs multiple jobs against multi-core CPUs. Example using all cores on Linux:
```bash
-echo "deb http://cran.rstudio.com/bin/linux/ubuntu trusty/" >> /etc/apt/sources.list
-gpg --keyserver keyserver.ubuntu.com --recv-key E084DAB9
-gpg -a --export E084DAB9 | apt-key add -
-
-apt-get update
-apt-get install -y r-base r-base-dev libxml2-dev libxt-dev libssl-dev
+make -j$(nproc)
```
-</div>
-
-Install the required R package dependencies:
+* Build without using OpenCV:
```bash
-cd R-package
-Rscript -e "install.packages('devtools', repo = 'https://cran.rstudio.com')"
-Rscript -e "library(devtools); library(methods); options(repos=c(CRAN='https://cran.rstudio.com')); install_deps(dependencies = TRUE)"
+make USE_OPENCV=0
```
-Next, build and install the MXNet R package:
+* Build with both OpenBLAS, GPU, and OpenCV support:
```bash
-cd ..
-make rpkg
+make -j USE_BLAS=openblas USE_CUDA=1 USE_CUDA_PATH=/usr/local/cuda USE_CUDNN=1
```
-## Build the Scala package
-
-Both JDK and Maven are required to build the Scala package.
-
-<div class="ubuntu">
+* Build on **macOS** with the default BLAS library (Apple Accelerate) and Clang installed with `xcode` (OPENMP is disabled because it is not supported by the Apple version of Clang):
```bash
-apt-get install -y software-properties-common
-add-apt-repository -y ppa:webupd8team/java
-apt-get update
-echo "oracle-java8-installer shared/accepted-oracle-license-v1-1 select true" | debconf-set-selections
-apt-get install -y oracle-java8-installer
-apt-get install -y oracle-java8-set-default
-apt-get install -y maven
+make -j USE_BLAS=apple USE_OPENCV=0 USE_OPENMP=0
```
-</div>
-
-The following command builds the `.jar` package:
+* To use OpenMP on **macOS** you need to install the Clang compiler, `llvm` (the one provided by Apple does not support OpenMP):
```bash
-make scalapkg
+brew install llvm
+make -j USE_BLAS=apple USE_OPENMP=1
```
-which can be found by `ls scala-package/assembly/*/target/*SNAPSHOT.jar`.
-
-Optionally, we can install Scala for the interactive interface.
+## Installing MXNet Language Bindings
+After building MXNet's shared library, you can install other language bindings. (Except for C++. You need to build this when you build MXNet from source.)
-<div class="ubuntu">
-
-```bash
-wget http://downloads.lightbend.com/scala/2.11.8/scala-2.11.8.deb
-dpkg -i scala-2.11.8.deb
-rm scala-2.11.8.deb
-```
-
-</div>
-
-Then we can start `scala` with `mxnet` imported by
-
-```bash
-scala -cp scala-package/assembly/*/target/*SNAPSHOT.jar
-```
-
-## Build the Julia package
-
-We need to first install Julia.
-
-<div class="ubuntu centos linux">
-
-The following commands install Julia 0.5.1
-
-```bash
-wget -q https://julialang.s3.amazonaws.com/bin/linux/x64/0.5/julia-0.5.1-linux-x86_64.tar.gz
-tar -zxf julia-0.5.1-linux-x86_64.tar.gz
-rm julia-0.5.1-linux-x86_64.tar.gz
-ln -s $(pwd)/julia-6445c82d00/bin/julia /usr/bin/julia
-```
-
-</div>
-
-Next set the environment variable `MXNET_HOME=/path/to/mxnet` so that Julia
-can find the pre-built library.
-
-Install the Julia package for MXNet with:
-
-```bash
-julia -e 'Pkg.add("MXNet")'
-```
-
-### Build the Perl package
-
-Run the following command from the MXNet source root directory to build the MXNet Perl package:
-
-```bash
- sudo apt-get install libmouse-perl pdl cpanminus swig libgraphviz-perl
- cpanm -q -L "${HOME}/perl5" Function::Parameters Hash::Ordered PDL::CCS
-
- MXNET_HOME=${PWD}
- export LD_LIBRARY_PATH=${MXNET_HOME}/lib
- export PERL5LIB=${HOME}/perl5/lib/perl5
-
- cd ${MXNET_HOME}/perl-package/AI-MXNetCAPI/
- perl Makefile.PL INSTALL_BASE=${HOME}/perl5
- make install
-
- cd ${MXNET_HOME}/perl-package/AI-NNVMCAPI/
- perl Makefile.PL INSTALL_BASE=${HOME}/perl5
- make install
-
- cd ${MXNET_HOME}/perl-package/AI-MXNet/
- perl Makefile.PL INSTALL_BASE=${HOME}/perl5
- make install
-```
+The following table provides links to each language binding by operating system:
+| | Linux | macOS | Windows |
+|---|---|---|---|
+| Python | [Linux](ubuntu_setup.html#install-mxnet-for-python) | [macOS](osx_setup.html) | [Windows](windows_setup.html#install-mxnet-for-python) |
+| C++ | [Linux](c_plus_plus.html) | [macOS](c_plus_plus.html) | [Windows](c_plus_plus.html) |
+| Clojure | [Linux](https://github.com/apache/incubator-mxnet/tree/master/contrib/clojure-package) | [macOS](https://github.com/apache/incubator-mxnet/tree/master/contrib/clojure-package) | n/a |
+| Julia | [Linux](ubuntu_setup.html#install-the-mxnet-package-for-julia) | [macOS](osx_setup.html#install-the-mxnet-package-for-julia) | [Windows](windows_setup.html#install-the-mxnet-package-for-julia) |
+| Perl | [Linux](ubuntu_setup.html#install-the-mxnet-package-for-perl) | [macOS](osx_setup.html#install-the-mxnet-package-for-perl) | [Windows](n/a) |
+| R | [Linux](ubuntu_setup.html#install-the-mxnet-package-for-r) | [macOS](osx_setup.html#install-the-mxnet-package-for-r) | [Windows](windows_setup.html#install-the-mxnet-package-for-r) |
+| Scala | [Linux](scala_setup.html) | [macOS](scala_setup.html) | n/a |
diff --git a/docs/install/c_plus_plus.md b/docs/install/c_plus_plus.md
new file mode 100644
index 00000000000..6078877c27c
--- /dev/null
+++ b/docs/install/c_plus_plus.md
@@ -0,0 +1,29 @@
+## Build the C++ package
+The C++ package has the same prerequisites as the MXNet library.
+
+To enable C++ package, just add `USE_CPP_PACKAGE=1` in the [build from source](build_from_source.html) options when building the MXNet shared library.
+
+For example to build MXNet with GPU support and the C++ package, OpenCV, and OpenBLAS, from the project root you would run:
+
+```bash
+make -j USE_CPP_PACKAGE=1 USE_OPENCV=1 USE_BLAS=openblas USE_CUDA=1
+```
+
+You may also want to add the MXNet shared library to your `LD_LIBRARY_PATH`:
+
+```bash
+export LD_LIBRARY_PATH=~/incubator-mxnet/lib
+```
+
+Setting the `LD_LIBRARY_PATH` is required to run the examples mentioned in the following section.
+
+## C++ Example Code
+You can find C++ code examples in the `cpp-package/example` folder of the MXNet project. Refer to the [cpp-package's README](https://github.com/apache/incubator-mxnet/tree/master/cpp-package) for instructions on building the examples.
+
+## Tutorials
+
+* [MXNet C++ API Basics](https://mxnet.incubator.apache.org/tutorials/c++/basics.html)
+
+## Related Topics
+
+* [Image Classification using MXNet's C Predict API](https://github.com/apache/incubator-mxnet/tree/master/example/image-classification/predict-cpp)
diff --git a/docs/install/centos_setup.md b/docs/install/centos_setup.md
index 42a4fcb0eb8..f63099bcf62 100644
--- a/docs/install/centos_setup.md
+++ b/docs/install/centos_setup.md
@@ -1,8 +1,90 @@
-<!-- This page should be deleted after sometime (Allowing search engines
-to update links) -->
-<meta http-equiv="refresh" content="3; url=http://mxnet.io/install/index.html" />
-<!-- Just in case redirection does not work -->
-<p>
- <a href="http://mxnet.io/install/index.html">
- This content is moved to a new MXNet install page. Redirecting... </a>
-</p>
+# Installing MXNet on CentOS and other non-Ubuntu Linux systems
+
+1. Install build tools and git on `CentOS >= 7` and `Fedora >= 19`:
+
+```bash
+sudo yum groupinstall -y "Development Tools" && sudo yum install -y git
+```
+
+2. Install Atlas:
+
+```bash
+sudo yum install atlas-devel
+```
+
+Installing both `git` and `cmake` or `make` by following instructions on the websites is
+straightforward. Here we provide the instructions to build `gcc-4.8` from source codes.
+
+3. Install the 32-bit `libc` with one of the following system-specific commands:
+
+```bash
+sudo apt-get install libc6-dev-i386 # In Ubuntu
+sudo yum install glibc-devel.i686 # In RHEL (Red Hat Linux)
+sudo yum install glibc-devel.i386 # In CentOS 5.8
+sudo yum install glibc-devel.i686 # In CentOS 6/7
+```
+
+4. Download and extract the `gcc` source code with the prerequisites:
+
+```bash
+wget http://mirrors.concertpass.com/gcc/releases/gcc-4.8.5/gcc-4.8.5.tar.gz
+tar -zxf gcc-4.8.5.tar.gz
+cd gcc-4.8.5
+./contrib/download_prerequisites
+```
+
+5. Build `gcc` by using 10 threads and then install to `/usr/local`
+
+```bash
+mkdir release && cd release
+../configure --prefix=/usr/local --enable-languages=c,c++
+make -j10
+sudo make install
+```
+
+6. Add the lib path to your configure file such as `~/.bashrc`:
+
+```bash
+export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/lib64
+```
+
+7. Build [OpenBLAS from source](https://github.com/xianyi/OpenBLAS#installation-from-source).
+
+8. Build OpenCV
+
+To build OpenCV from source code, you need the [cmake](https://cmake.org) library.
+
+* If you don't have cmake or if your version of cmake is earlier than 3.6.1, run the following commands to install a newer version of cmake:
+
+ ```bash
+ wget https://cmake.org/files/v3.6/cmake-3.6.1-Linux-x86_64.tar.gz
+ tar -zxvf cmake-3.6.1-Linux-x86_64.tar.gz
+ alias cmake="cmake-3.6.1-Linux-x86_64/bin/cmake"
+ ```
+
+* To download and extract the OpenCV source code, run the following commands:
+
+ ```bash
+ wget https://codeload.github.com/opencv/opencv/zip/2.4.13
+ unzip 2.4.13
+ cd opencv-2.4.13
+ mkdir release
+ cd release/
+ ```
+
+* Build OpenCV. The following commands build OpenCV with 10 threads. We
+ disabled GPU support, which might significantly slow down an MXNet program
+ running on a GPU processor. It also disables 1394 which might generate a
+ warning. Then install it on `/usr/local`.
+
+ ```bash
+ cmake -D BUILD_opencv_gpu=OFF -D WITH_CUDA=OFF -D WITH_1394=OFF -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local ..
+ make -j10
+ sudo make install
+ ```
+
+* Add the lib path to your configuration such as `~/.bashrc`.
+
+ ```bash
+ export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig/
+ ```
diff --git a/docs/install/index.md b/docs/install/index.md
index 833bedf08af..4a6af31cee3 100644
--- a/docs/install/index.md
+++ b/docs/install/index.md
@@ -1,6 +1,6 @@
# Installing MXNet
-Indicate your preferred configuration. Then, follow the customized commands to install *MXNet*.
+Indicate your preferred configuration. Then, follow the customized commands to install MXNet.
<div class="dropdown">
<button class="btn current-version btn-primary dropdown-toggle" type="button" data-toggle="dropdown">v1.2.1
@@ -63,14 +63,13 @@ Indicate your preferred configuration. Then, follow the customized commands to i
<div class="cpu gpu">
<div class="btn-group opt-group" role="group">
<button type="button" class="btn btn-default environs opt active">Pip</button>
- <button type="button" class="btn btn-default environs opt">Virtualenv</button>
<button type="button" class="btn btn-default environs opt">Docker</button>
<button type="button" class="btn btn-default environs opt">Build from Source</button>
</div>
</div>
</div>
</div>
-
+<hr>
<!-- END - Main Menu -->
<!-- START - Linux Python CPU Installation Instructions -->
@@ -78,88 +77,27 @@ Indicate your preferred configuration. Then, follow the customized commands to i
<div class="linux">
<div class="python">
<div class="cpu">
-
-The following installation instructions have been tested on Ubuntu 14.04 and 16.04.
-
-
<div class="pip">
-<br/>
-
-**Step 1** Install prerequisites - wget and latest pip.
-
-Installing *MXNet* with pip requires a latest version of `pip`. Install the latest version of `pip` by issuing the following command in the terminal.
-
-```bash
-$ sudo apt-get update
-$ sudo apt-get install -y wget python gcc
-$ wget https://bootstrap.pypa.io/get-pip.py && sudo python get-pip.py
-```
-
<div class="v1-2-1">
-**Step 2** Install MXNet with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet
-```
-
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
```
-
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
-
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-mkl
+$ pip install mxnet
```
</div> <!-- End of v1-2-1 -->
<div class="v1-1-0">
-**Step 2** Install MXNet with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet==1.1.0
-```
-
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
```
-
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
-
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-mkl==1.1.0
+$ pip install mxnet==1.1.0
```
</div> <!-- End of v1-1-0-->
<div class="v1-0-0">
-**Step 2** Install MXNet with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet==1.0.0
-```
-
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
```
-
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
-
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-mkl==1.0.0
+$ pip install mxnet==1.0.0
```
</div> <!-- End of v1-0-0-->
@@ -167,210 +105,159 @@ $ pip install mxnet-mkl==1.0.0
<div class="v0-12-1">
-
-**Step 2** Install MXNet with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet==0.12.1
-```
-
-For MXNet 0.12.0 -
-
-```bash
-$ pip install mxnet==0.12.0
```
-
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
+$ pip install mxnet==0.12.1
```
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+For MXNet 0.12.0:
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-mkl==0.12.1
```
-
-For MXNet 0.12.0 -
-
-```bash
-$ pip install mxnet-mkl==0.12.0
+$ pip install mxnet==0.12.0
```
</div> <!-- End of v0-12-1-->
<div class="v0-11-0">
-
-**Step 2** Install MXNet with OpenBLAS acceleration.
-
-```bash
+```
$ pip install mxnet==0.11.0
```
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
+</div> <!-- End of v0-11-0-->
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+<div class="master">
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-mkl==0.11.0
+```
+$ pip install mxnet --pre
```
-</div> <!-- End of v0-11-0-->
+</div> <!-- End of master-->
+<hr> <!-- pip footer -->
+Most MXNet versions offer an experimental MKL pip package that will be much faster when running on Intel hardware.
+Check the chart below for other options, refer to <a href="https://pypi.org/project/mxnet/">PyPI for other MXNet pip packages</a>, or <a href="validate_mxnet.html">validate your MXNet installation</a>.
-<div class="master">
+<img src="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/install/pip-packages.png" alt="pip packages"/>
+</div> <!-- End of pip -->
-**Step 2** Install MXNet with OpenBLAS acceleration.
-```bash
-$ pip install mxnet --pre
-```
+<div class="docker">
+<br/>
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
+Docker images with *MXNet* are available at [Docker Hub](https://hub.docker.com/r/mxnet/).
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+**Step 1** Install Docker on your machine by following the [docker installation instructions](https://docs.docker.com/engine/installation/linux/ubuntu/#install-using-the-repository).
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-mkl --pre
-```
+*Note* - You can install Community Edition (CE) to get started with *MXNet*.
-</div> <!-- End of master-->
+**Step 2** [Optional] Post installation steps to manage Docker as a non-root user.
-</div> <!-- End of pip -->
+Follow the four steps in this [docker documentation](https://docs.docker.com/engine/installation/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow managing docker containers without *sudo*.
-<div class="virtualenv">
-<br/>
+If you skip this step, you need to use *sudo* each time you invoke Docker.
-**Step 1** Install virtualenv for Ubuntu.
+**Step 3** Pull the MXNet docker image.
-```bash
-$ sudo apt-get update
-$ sudo apt-get install -y python-dev python-virtualenv
+```
+$ docker pull mxnet/python # Use sudo if you skip Step 2
```
-**Step 2** Create and activate virtualenv environment for MXNet.
+You can list docker images to see if mxnet/python docker image pull was successful.
-Following command creates a virtualenv environment at `~/mxnet` directory. However, you can choose any directory by replacing `~/mxnet` with a directory of your choice.
+```
+$ docker images # Use sudo if you skip Step 2
-```bash
-$ virtualenv --system-site-packages ~/mxnet
+REPOSITORY TAG IMAGE ID CREATED SIZE
+mxnet/python latest 00d026968b3c 3 weeks ago 1.41 GB
```
-Activate the virtualenv environment created for *MXNet*.
+**Step 4** <a href="validate_mxnet.html">Validate the installation</a>.
-```bash
-$ source ~/mxnet/bin/activate
-```
+</div> <!-- END of docker -->
-After activating the environment, you should see the prompt as below.
+<div class="build-from-source">
+<br/>
-```bash
-(mxnet)$
-```
+To build from source, refer to the <a href="ubuntu_setup.html">MXNet Ubuntu installation guide</a>.
-**Step 3** Install MXNet in the active virtualenv environment.
+</div><!-- END of build from source -->
-Installing *MXNet* with pip requires a latest version of `pip`. Install the latest version of `pip` by issuing the following command.
+</div><!-- END of CPU -->
+<!-- END - Linux Python CPU Installation Instructions -->
-```bash
-$ pip install --upgrade pip
-```
+<!-- START - Linux Python GPU Installation Instructions -->
+<div class="gpu">
+<div class="pip">
<div class="v1-2-1">
-Install *MXNet* with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet
+```
+$ pip install mxnet-cu92
```
</div> <!-- End of v1-2-1-->
<div class="v1-1-0">
-Install *MXNet* with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet==1.1.0
+```
+$ pip install mxnet-cu91==1.1.0
```
</div> <!-- End of v1-1-0-->
<div class="v1-0-0">
-Install *MXNet* with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet==1.0.0
+```
+$ pip install mxnet-cu90==1.0.0
```
</div> <!-- End of v1-0-0-->
-
<div class="v0-12-1">
-Install *MXNet* with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet==0.12.1
```
-
-For *MXNet* 0.12.0 -
-
-```bash
-$ pip install mxnet==0.12.0
+$ pip install mxnet-cu90==0.12.1
```
</div> <!-- End of v0-12-1-->
<div class="v0-11-0">
-Install *MXNet* with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet==0.11.0
+```
+$ pip install mxnet-cu80==0.11.0
```
</div> <!-- End of v0-11-0-->
<div class="master">
-Install *MXNet* with OpenBLAS acceleration.
-
-```bash
-$ pip install mxnet --pre
+```
+$ pip install mxnet-cu92 --pre
```
</div> <!-- End of master-->
+<hr> <!-- pip footer -->
+Most MXNet versions offer an experimental MKL pip package that will be much faster when running on Intel hardware.
+Check the chart below for other options, refer to <a href="https://pypi.org/project/mxnet/">PyPI for other MXNet pip packages</a>, or <a href="validate_mxnet.html">validate your MXNet installation</a>.
+<img src="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/install/pip-packages.png" alt="pip packages"/>
-**Step 4** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
+**NOTES:**
-**Step 5** Validate the installation by running simple *MXNet* code described [here](#validate-mxnet-installation).
+CUDA should be installed first. Instructions can be found in the <a href="ubuntu_setup.html#cuda-dependencies">CUDA dependencies section of the MXNet Ubuntu installation guide</a>.
-**Note** You can read more about virtualenv [here](https://virtualenv.pypa.io/en/stable/userguide/).
+**Important:** Make sure your installed CUDA version matches the CUDA version in the pip package. Check your CUDA version with the following command:
+
+```
+nvcc --version
+```
-</div> <!-- END of virtualenv -->
+You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
+</div> <!-- END of pip -->
<div class="docker">
+
<br/>
Docker images with *MXNet* are available at [Docker Hub](https://hub.docker.com/r/mxnet/).
@@ -385,2146 +272,806 @@ Follow the four steps in this [docker documentation](https://docs.docker.com/eng
If you skip this step, you need to use *sudo* each time you invoke Docker.
-**Step 3** Pull the MXNet docker image.
+**Step 3** Install *nvidia-docker-plugin* following the [installation instructions](https://github.com/NVIDIA/nvidia-docker/wiki/Installation). *nvidia-docker-plugin* is required to enable the usage of GPUs from the docker containers.
-```bash
-$ docker pull mxnet/python # Use sudo if you skip Step 2
+**Step 4** Pull the MXNet docker image.
+
+```
+$ docker pull mxnet/python:gpu # Use sudo if you skip Step 2
```
You can list docker images to see if mxnet/python docker image pull was successful.
-```bash
+```
$ docker images # Use sudo if you skip Step 2
REPOSITORY TAG IMAGE ID CREATED SIZE
-mxnet/python latest 00d026968b3c 3 weeks ago 1.41 GB
+mxnet/python gpu 493b2683c269 3 weeks ago 4.77 GB
```
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+**Step 5** <a href="validate_mxnet.html">Validate the installation</a>.
</div> <!-- END of docker -->
<div class="build-from-source">
<br/>
+Refer to the <a href="ubuntu_setup.html">MXNet Ubuntu installation guide</a>.
-Building *MXNet* from source is a 2 step process.
-1. Build the *MXNet* core shared library, `libmxnet.so`, from the C++ sources.
-2. Build the language specific bindings. Example - Python bindings, Scala bindings.
-**Minimum Requirements**
-1. [GCC 4.8](https://gcc.gnu.org/gcc-4.8/) or later to compile C++ 11.
-2. [GNU Make](https://www.gnu.org/software/make/)
+</div> <!-- END of build from source -->
+</div> <!-- END of GPU -->
+</div> <!-- END of Python -->
+<!-- END - Linux Python GPU Installation Instructions -->
-<br/>
-**Build the MXNet core shared library**
+<div class="r">
+<div class="cpu">
-**Step 1** Install build tools and git.
-```bash
-$ sudo apt-get update
-$ sudo apt-get install -y build-essential git
-```
+The default version of R that is installed with `apt-get` is insufficient. You will need to first [install R v3.4.4+ and build MXNet from source](ubuntu_setup.html#install-the-mxnet-package-for-r).
-**Step 2** Install OpenBLAS.
+After you have setup R v3.4.4+ and MXNet, you can build and install the MXNet R bindings with the following, assuming that `incubator-mxnet` is the source directory you used to build MXNet as follows:
-*MXNet* uses [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) and [LAPACK](https://en.wikipedia.org/wiki/LAPACK) libraries for accelerated numerical computations on CPU machine. There are several flavors of BLAS/LAPACK libraries - [OpenBLAS](http://www.openblas.net/), [ATLAS](http://math-atlas.sourceforge.net/) and [MKL](https://software.intel.com/en-us/intel-mkl). In this step we install OpenBLAS. You can choose to install ATLAS or MKL.
-```bash
-$ sudo apt-get install -y libopenblas-dev liblapack-dev
+```
+$ cd incubator-mxnet
+$ make rpkg
```
-**Step 3** Install OpenCV.
+</div> <!-- END of CPU -->
-*MXNet* uses [OpenCV](http://opencv.org/) for efficient image loading and augmentation operations.
-```bash
-$ sudo apt-get install -y libopencv-dev
-```
-**Step 4** Download MXNet sources and build MXNet core shared library. You can clone the repository as described in the following code block, or you may try the <a href="download.html">download links</a> for your desired MXNet version.
+<div class="gpu">
+
+The default version of R that is installed with `apt-get` is insufficient. You will need to first [install R v3.4.4+ and build MXNet from source](ubuntu_setup.html#install-the-mxnet-package-for-r).
+
+After you have setup R v3.4.4+ and MXNet, you can build and install the MXNet R bindings with the following, assuming that `incubator-mxnet` is the source directory you used to build MXNet as follows:
-```bash
-$ git clone --recursive https://github.com/apache/incubator-mxnet
+```
$ cd incubator-mxnet
-$ make -j $(nproc) USE_OPENCV=1 USE_BLAS=openblas
+$ make rpkg
```
-*Note* - USE_OPENCV and USE_BLAS are make file flags to set compilation options to use OpenCV and BLAS library. You can explore and use more compilation options in `make/config.mk`.
+</div> <!-- END of GPU -->
+</div> <!-- END of R -->
-<br/>
-**Build the MXNet Python binding**
+<div class="scala">
+<div class="gpu">
+<br/>
+You can use the Maven packages defined in the following `dependency` to include MXNet in your Scala project. Please refer to the <a href="scala_setup.html">MXNet-Scala setup guide</a> for a detailed set of instructions to help you with the setup process.
-**Step 1** Install prerequisites - python, setup-tools, python-pip and libfortran (required for Numpy).
+<a href="https://mvnrepository.com/artifact/org.apache.mxnet/mxnet-full_2.11-linux-x86_64-gpu"><img src="https://img.shields.io/badge/org.apache.mxnet-linux gpu-green.svg" alt="maven badge"/></a>
-```bash
-$ sudo apt-get install -y python-dev python-setuptools python-pip libgfortran3
+```html
+<dependency>
+ <groupId>org.apache.mxnet</groupId>
+ <artifactId>mxnet-full_2.11-linux-x86_64-gpu</artifactId>
+</dependency>
```
+<br>
+</div> <!-- End of gpu -->
-**Step 2** Install the MXNet Python binding.
-
-```bash
-$ cd python
-$ pip install -e .
-```
+<div class="cpu">
+<br/>
+You can use the Maven packages defined in the following `dependency` to include MXNet in your Scala project. Please refer to the <a href="scala_setup.html">MXNet-Scala setup guide</a> for a detailed set of instructions to help you with the setup process.
-Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
+<a href="https://mvnrepository.com/artifact/org.apache.mxnet/mxnet-full_2.11-linux-x86_64-cpu"><img src="https://img.shields.io/badge/org.apache.mxnet-linux cpu-green.svg" alt="maven badge"/></a>
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
+```html
+<dependency>
+ <groupId>org.apache.mxnet</groupId>
+ <artifactId>mxnet-full_2.11-linux-x86_64-cpu</artifactId>
+</dependency>
```
+<br>
+</div> <!-- End of cpu -->
+</div> <!-- End of scala -->
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
-</div><!-- END of build from source -->
-</div><!-- END of CPU -->
-<!-- END - Linux Python CPU Installation Instructions -->
+<div class="julia">
+<div class="cpu gpu">
+</br>
+Refer to the <a href="ubuntu_setup.html#install-the-mxnet-package-for-julia">Julia section of the MXNet Ubuntu installation guide</a>.
-<!-- START - Linux Python GPU Installation Instructions -->
+</div> <!-- End of cpu gpu -->
+</div> <!-- End of julia -->
-<div class="gpu">
+<div class="perl">
+<div class="cpu gpu">
+</br>
+Refer to the <a href="ubuntu_setup.html#install-the-mxnet-package-for-perl">Perl section of the MXNet Ubuntu installation guide</a>.
-The following installation instructions have been tested on Ubuntu 14.04 and 16.04.
+</div> <!-- End of cpu gpu -->
+</div> <!-- End of julia -->
-**Prerequisites**
-Install the following NVIDIA libraries to setup *MXNet* with GPU support:
+<div class="cpp">
+<div class="cpu gpu">
+<br/>
+<p>To enable the C++ package, build from source using `make USE_CPP_PACKAGE=1`.
+<br/>Refer to the <a href="c_plus_plus.html">MXNet C++ setup guide</a> for more info.</p>
+<br/>
+</div> <!-- End of cpu gpu -->
+</div> <!-- END - C++-->
+<hr>
+For more installation options, refer to the <a href="ubuntu_setup.html">MXNet Ubuntu installation guide</a>.
-1. Install CUDA 9.0 following the NVIDIA's [installation guide](http://docs.nvidia.com/cuda/cuda-installation-guide-linux/).
-2. Install cuDNN 7 for CUDA 9.0 following the NVIDIA's [installation guide](https://developer.nvidia.com/cudnn). You may need to register with NVIDIA for downloading the cuDNN library.
+</div> <!-- END - Linux -->
-**Note:** Make sure to add CUDA install path to `LD_LIBRARY_PATH`.
-Example - *export LD_LIBRARY_PATH=/usr/local/cuda/lib64/:$LD_LIBRARY_PATH*
+<!-- START - MacOS Python CPU Installation Instructions -->
+<div class="macos">
+<div class="python">
+<div class="cpu">
<div class="pip">
-<br/>
-
-**Step 1** Install prerequisites - wget and latest pip.
-
-Installing *MXNet* with pip requires a latest version of `pip`. Install the latest version of `pip` by issuing the following command in the terminal.
+<div class="v1-2-1">
-```bash
-$ sudo apt-get update
-$ sudo apt-get install -y wget python
-$ wget https://bootstrap.pypa.io/get-pip.py && sudo python get-pip.py
+```
+$ pip install mxnet
```
-<div class="v1-2-1">
+</div> <!-- End of v1-2-1 -->
-**Step 2** Install *MXNet* with GPU support using CUDA 9.2
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
+<div class="v1-1-0">
-```bash
-nvcc --version
```
-
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
-
-```bash
-$ pip install mxnet-cu92
+$ pip install mxnet==1.1.0
```
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
+</div> <!-- End of v1-1-0-->
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+<div class="v1-0-0">
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-cu90mkl
+```
+$ pip install mxnet==1.0.0
```
-</div> <!-- End of v1-2-1-->
-
-
-<div class="v1-1-0">
-
-**Step 2** Install *MXNet* with GPU support using CUDA 9.1
+</div> <!-- End of v1-0-0-->
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
+<div class="v0-12-1">
-```bash
-nvcc --version
+```
+$ pip install mxnet=0.12.1
```
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
+</div> <!-- End of v0-12-1-->
-```bash
-$ pip install mxnet-cu91==1.1.0
-```
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
+<div class="v0-11-0">
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
```
+$ pip install mxnet==0.11.0
+```
+
+</div> <!-- End of v0-11-0-->
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+<div class="master">
-**Experimental Choice** If You would like to install MXNet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-cu91mkl==1.1.0
+```
+$ pip install mxnet --pre
```
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
+</div> <!-- End of master-->
+<hr> <!-- pip footer -->
+Most MXNet versions offer an experimental MKL pip package that will be much faster when running on Intel hardware.
+Check the chart below for other options, refer to <a href="https://pypi.org/project/mxnet/">PyPI for other MXNet pip packages</a>, or <a href="validate_mxnet.html">validate your MXNet installation</a>.
-</div> <!-- End of v1-1-0-->
+<img src="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/install/pip-packages.png" alt="pip packages"/>
-<div class="v1-0-0">
+</div> <!-- END of pip -->
-**Step 2** Install *MXNet* with GPU support using CUDA 9.0
-
-```bash
-$ pip install mxnet-cu90==1.0.0
-```
-
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
-
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
-
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-cu90mkl==1.0.0
-```
-
-</div> <!-- End of v1-0-0-->
+<div class="docker">
+<br/>
-<div class="v0-12-1">
+Docker images with *MXNet* are available at [Docker Hub](https://hub.docker.com/r/mxnet/).
-**Step 2** Install *MXNet* with GPU support using CUDA 9.0
+**Step 1** Install Docker on your machine by following the [docker installation instructions](https://docs.docker.com/docker-for-mac/install/#install-and-run-docker-for-mac).
-```bash
-$ pip install mxnet-cu90==0.12.1
-```
+*Note* - You can install Community Edition (CE) to get started with *MXNet*.
-For *MXNet* 0.12.0 -
+**Step 2** Pull the MXNet docker image.
-```bash
-$ pip install mxnet-cu90==0.12.0
```
-
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
+$ docker pull mxnet/python
```
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+You can list docker images to see if mxnet/python docker image pull was successful.
-**Experimental Choice** If You would like to install mxnet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-cu90mkl==0.12.1
```
+$ docker images
-For *MXNet* 0.12.0 -
-
-```bash
-$ pip install mxnet-cu90mkl==0.12.0
+REPOSITORY TAG IMAGE ID CREATED SIZE
+mxnet/python latest 00d026968b3c 3 weeks ago 1.41 GB
```
-</div> <!-- End of v0-12-1-->
-
-
-<div class="v0-11-0">
+**Step 4** <a href="validate_mxnet.html">Validate the installation</a>.
-**Step 2** Install *MXNet* with GPU support using CUDA 8.0
+</div> <!-- END of docker -->
-```bash
-$ pip install mxnet-cu80==0.11.0
-```
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
+<div class="build-from-source">
+<br/>
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+To build from source, refer to the <a href="osx_setup.html">MXNet macOS installation guide</a>.
-**Experimental Choice** If You would like to install MXNet with Intel MKL, try the experimental pip package with MKL:
-```bash
-$ pip install mxnet-cu80mkl==0.11.0
-```
+MXNet developers should refer to the MXNet wiki's <a href="https://cwiki.apache.org/confluence/display/MXNET/MXNet+Developer+Setup+on+Mac">Developer Setup on Mac</a>.
+<br/>
+</div> <!-- END of build from source -->
+</div> <!-- END of CPU -->
-</div> <!-- End of v0-11-0-->
+<!-- START - Mac OS Python GPU Installation Instructions -->
+<div class="gpu">
+<div class="pip docker">
+<br/>
+This option is only available by building from source. Refer to the <a href="osx_setup.html">MXNet macOS installation guide</a>.
+<br/>
+</div>
-</div> <!-- END of pip -->
+<div class="build-from-source">
+<br/>
-<div class="virtualenv">
+Refer to the <a href="osx_setup.html">MXNet macOS installation guide</a>.
+MXNet developers should refer to the MXNet wiki's <a href="https://cwiki.apache.org/confluence/display/MXNET/MXNet+Developer+Setup+on+Mac">Developer Setup on Mac</a>.
<br/>
+</div> <!-- END of build from source -->
+</div> <!-- END of GPU -->
+</div> <!-- END of Python -->
-**Step 1** Install virtualenv for Ubuntu.
-```bash
-$ sudo apt-get update
-$ sudo apt-get install -y python-dev python-virtualenv
-```
+<!-- START - MacOS R CPU Installation Instructions -->
-**Step 2** Create and activate virtualenv environment for MXNet.
+<div class="r">
+<div class="cpu">
+</br>
-Following command creates a virtualenv environment at `~/mxnet` directory. However, you can choose any directory by replacing `~/mxnet` with a directory of your choice.
+Install the latest version (3.5.1+) of R from [CRAN](https://cran.r-project.org/bin/macosx/).
+You can [build MXNet-R from source](osx_setup.html#install-the-mxnet-package-for-r), or you can use a pre-built binary:
-```bash
-$ virtualenv --system-site-packages ~/mxnet
+```r
+cran <- getOption("repos")
+cran["dmlc"] <- "https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/R/CRAN/"
+options(repos = cran)
+install.packages("mxnet")
```
-Activate the virtualenv environment created for *MXNet*.
+</div> <!-- END of CPU -->
-```bash
-$ source ~/mxnet/bin/activate
-```
-After activating the environment, you should see the prompt as below.
+<div class="gpu">
+</br>
+Will be available soon.
-```bash
-(mxnet)$
-```
+</div> <!-- END of GPU -->
+</div> <!-- END of R -->
-**Step 3** Install MXNet in the active virtualenv environment.
+<div class="scala">
+<div class="cpu">
+</br>
+You can use the Maven packages defined in the following `dependency` to include MXNet in your Scala project. Please refer to the <a href="scala_setup.html">MXNet-Scala setup guide</a> for a detailed set of instructions to help you with the setup process.
-Installing *MXNet* with pip requires a latest version of `pip`. Install the latest version of `pip` by issuing the following command.
+<a href="https://mvnrepository.com/artifact/org.apache.mxnet/mxnet-full_2.11-osx-x86_64-cpu"><img src="https://img.shields.io/badge/org.apache.mxnet-mac cpu-green.svg" alt="maven badge"/></a>
-```bash
-(mxnet)$ pip install --upgrade pip
+```html
+<dependency>
+ <groupId>org.apache.mxnet</groupId>
+ <artifactId>mxnet-full_2.11-osx-x86_64-cpu</artifactId>
+</dependency>
```
+<br>
+</div> <!-- End of cpu -->
+<div class="gpu">
+Not available at this time. <br>
-<div class="v1-2-1">
+</div>
+</div> <!-- End of scala -->
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
-```bash
-nvcc --version
-```
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
+<div class="julia">
+<div class="cpu gpu">
+</br>
+Refer to the <a href="osx_setup.html#install-the-mxnet-package-for-julia">Julia section of the MXNet macOS installation guide</a>.
-Install *MXNet* with GPU support using CUDA 9.2:
+</div> <!-- End of cpu gpu -->
+</div> <!-- End of julia -->
-```bash
-(mxnet)$ pip install mxnet-cu92
-```
+<div class="perl">
+<div class="cpu gpu">
+</br>
+Refer to the <a href="osx_setup.html#install-the-mxnet-package-for-perl">Perl section of the MXNet macOS installation guide</a>.
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
+</div> <!-- End of cpu gpu -->
+</div> <!-- End of julia -->
-</div> <!-- End of v1-2-1-->
-<div class="v1-1-0">
+<div class="cpp">
+<br/>
+<p>To enable the C++ package, build from source using `make USE_CPP_PACKAGE=1`.
+<br/>Refer to the <a href="c_plus_plus.html">MXNet C++ setup guide</a> for more info.</p>
+<br/>
+</div>
+<hr>
+For more installation options, refer to the <a href="osx_setup.html">MXNet macOS installation guide</a>.
+</div> <!-- END - Mac OS -->
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
-```bash
-nvcc --version
+
+<div class="windows">
+<div class="python">
+<div class="cpu">
+<div class="pip">
+<div class="v1-2-1">
+
+```
+$ pip install mxnet
```
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
+</div> <!-- End of v1-2-1-->
-Install *MXNet* with GPU support using CUDA 9.1:
+<div class="v1-1-0">
-```bash
-(mxnet)$ pip install mxnet-cu91==1.1.0
```
-
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
+$ pip install mxnet==1.1.0
+```
</div> <!-- End of v1-1-0-->
-
<div class="v1-0-0">
-Install *MXNet* with GPU support using CUDA 9.0.
-
-```bash
-(mxnet)$ pip install mxnet-cu90==1.0.0
```
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
+$ pip install mxnet==1.0.0
+```
</div> <!-- End of v1-0-0-->
-
<div class="v0-12-1">
-Install *MXNet* with GPU support using CUDA 9.0.
-
-```bash
-(mxnet)$ pip install mxnet-cu90==0.12.1
```
-
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
+$ pip install mxnet==0.12.1
+```
</div> <!-- End of v0-12-1-->
-
<div class="v0-11-0">
-Install *MXNet* with GPU support using CUDA 8.0.
-
-```bash
-(mxnet)$ pip install mxnet-cu80==0.11.0
+```
+$ pip install mxnet==0.11.0
```
</div> <!-- End of v0-11-0-->
<div class="master">
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
-
-```bash
-nvcc --version
```
-
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
-
-Install *MXNet* with GPU support using CUDA 9.2.
-
-```bash
-(mxnet)$ pip install mxnet-cu92 --pre
+$ pip install mxnet --pre
```
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
-
</div> <!-- End of master-->
+<hr> <!-- pip footer -->
+Most MXNet versions offer an experimental MKL pip package that will be much faster when running on Intel hardware.
+Check the chart below for other options, refer to <a href="https://pypi.org/project/mxnet/">PyPI for other MXNet pip packages</a>, or <a href="validate_mxnet.html">validate your MXNet installation</a>.
-**Step 4** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
-
-**Step 5** Validate the installation by running simple *MXNet* code described [here](#validate-mxnet-installation).
+<img src="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/install/pip-packages.png" alt="pip packages"/>
-**Note** You can read more about virtualenv [here](https://virtualenv.pypa.io/en/stable/userguide/).
-</div> <!-- END of virtualenv -->
+</div> <!-- End of pip -->
-<div class="docker">
+<div class="docker build-from-source">
<br/>
-Docker images with *MXNet* are available at [Docker Hub](https://hub.docker.com/r/mxnet/).
+Refer to the <a href="windows_setup.html">MXNet Windows installation guide</a>.
-**Step 1** Install Docker on your machine by following the [docker installation instructions](https://docs.docker.com/engine/installation/linux/ubuntu/#install-using-the-repository).
-*Note* - You can install Community Edition (CE) to get started with *MXNet*.
+</div> <!-- End of docker build-from-source -->
+</div> <!-- End of CPU -->
-**Step 2** [Optional] Post installation steps to manage Docker as a non-root user.
-Follow the four steps in this [docker documentation](https://docs.docker.com/engine/installation/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow managing docker containers without *sudo*.
+<div class="gpu">
+<div class="pip">
+<div class="v1-2-1">
-If you skip this step, you need to use *sudo* each time you invoke Docker.
+```
+$ pip install mxnet-cu92
+```
-**Step 3** Install *nvidia-docker-plugin* following the [installation instructions](https://github.com/NVIDIA/nvidia-docker/wiki/Installation). *nvidia-docker-plugin* is required to enable the usage of GPUs from the docker containers.
+</div> <!-- End of v1-2-1-->
-**Step 4** Pull the MXNet docker image.
+<div class="v1-1-0">
-```bash
-$ docker pull mxnet/python:gpu # Use sudo if you skip Step 2
+```
+$ pip install mxnet-cu91==1.1.0
```
-You can list docker images to see if mxnet/python docker image pull was successful.
+</div> <!-- End of v1-1-0-->
-```bash
-$ docker images # Use sudo if you skip Step 2
+<div class="v1-0-0">
-REPOSITORY TAG IMAGE ID CREATED SIZE
-mxnet/python gpu 493b2683c269 3 weeks ago 4.77 GB
+```
+$ pip install mxnet-cu90==1.0.0
```
-**Step 5** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+</div> <!-- End of v1-0-0-->
-</div> <!-- END of docker -->
+<div class="v0-12-1">
-<div class="build-from-source">
+```
+$ pip install mxnet-cu90==0.12.1
+```
-<br/>
+</div> <!-- End of v0-12-1-->
-Building *MXNet* from source is a 2 step process.
-1. Build the *MXNet* core shared library, `libmxnet.so`, from the C++ sources.
-2. Build the language specific bindings. Example - Python bindings, Scala bindings.
+<div class="v0-11-0">
-**Minimum Requirements**
-1. [GCC 4.8](https://gcc.gnu.org/gcc-4.8/) or later to compile C++ 11.
-2. [GNU Make](https://www.gnu.org/software/make/)
+```
+$ pip install mxnet-cu80==0.11.0
+```
-<br/>
+</div> <!-- End of v0-11-0-->
-**Build the MXNet core shared library**
+<div class="master">
-**Step 1** Install build tools and git.
-```bash
-$ sudo apt-get update
-$ sudo apt-get install -y build-essential git
```
-**Step 2** Install OpenBLAS.
-
-*MXNet* uses [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) and [LAPACK](https://en.wikipedia.org/wiki/LAPACK) libraries for accelerated numerical computations on CPU machine. There are several flavors of BLAS/LAPACK libraries - [OpenBLAS](http://www.openblas.net/), [ATLAS](http://math-atlas.sourceforge.net/) and [MKL](https://software.intel.com/en-us/intel-mkl). In this step we install OpenBLAS. You can choose to install ATLAS or MKL.
-```bash
-$ sudo apt-get install -y libopenblas-dev liblapack-dev
+$ pip install mxnet-cu92 --pre
```
-**Step 3** Install OpenCV.
+</div> <!-- End of master-->
+<hr> <!-- pip footer -->
+Most MXNet versions offer an experimental MKL pip package that will be much faster when running on Intel hardware.
+Check the chart below for other options, refer to <a href="https://pypi.org/project/mxnet/">PyPI for other MXNet pip packages</a>, or <a href="validate_mxnet.html">validate your MXNet installation</a>.
-*MXNet* uses [OpenCV](http://opencv.org/) for efficient image loading and augmentation operations.
-```bash
-$ sudo apt-get install -y libopencv-dev
-```
+<img src="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/install/pip-packages.png" alt="pip packages"/>
-**Step 4** Download MXNet sources and build MXNet core shared library. You can clone the repository as described in the following code block, or you may try the <a href="download.html">download links</a> for your desired MXNet version.
+**NOTES:**
-```bash
-$ git clone --recursive https://github.com/apache/incubator-mxnet
-$ cd incubator-mxnet
-$ make -j $(nproc) USE_OPENCV=1 USE_BLAS=openblas USE_CUDA=1 USE_CUDA_PATH=/usr/local/cuda USE_CUDNN=1
-```
+[Anaconda](https://www.anaconda.com/download/) is recommended.
-*Note* - USE_OPENCV, USE_BLAS, USE_CUDA, USE_CUDA_PATH AND USE_CUDNN are make file flags to set compilation options to use OpenCV, OpenBLAS, CUDA and cuDNN libraries. You can explore and use more compilation options in `make/config.mk`. Make sure to set USE_CUDA_PATH to right CUDA installation path. In most cases it is - */usr/local/cuda*.
+CUDA should be installed first. Instructions can be found in the <a href="ubuntu_setup.html#cuda-dependencies">CUDA dependencies section of the MXNet Ubuntu installation guide</a>.
-<br/>
+**Important:** Make sure your installed CUDA version matches the CUDA version in the pip package. Check your CUDA version with the following command:
-**Install the MXNet Python binding**
+```
+nvcc --version
+```
-**Step 1** Install prerequisites - python, setup-tools, python-pip and libfortran (required for Numpy)..
+Refer to [#8671](https://github.com/apache/incubator-mxnet/issues/8671) for status on CUDA 9.1 support.
-```bash
-$ sudo apt-get install -y python-dev python-setuptools python-pip libgfortran3
-```
+You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
-**Step 2** Install the MXNet Python binding.
+</div>
-```bash
-$ cd python
-$ pip install -e .
-```
+<div class="build-from-source">
+<br/>
-Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
+To build from source, refer to the <a href="windows_setup.html">MXNet Windows installation guide</a>.
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-sudo apt-get install graphviz
-pip install graphviz
-```
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+</div> <!-- End of pip -->
+</div> <!-- End of GPU -->
+</div> <!-- End of Python -->
-</div> <!-- END of build from source -->
-</div> <!-- END of GPU -->
-</div> <!-- END of Python -->
-<!-- END - Linux Python GPU Installation Instructions -->
+<!-- START - Windows R CPU Installation Instructions -->
<div class="r">
<div class="cpu">
+</br>
-The default version of R that is installed with `apt-get` is insufficient. You will need to first [install R v3.4.4+ and build MXNet from source](ubuntu_setup.html#install-the-mxnet-package-for-r).
-
-After you have setup R v3.4.4+ and MXNet, you can build and install the MXNet R bindings with the following, assuming that `incubator-mxnet` is the source directory you used to build MXNet as follows:
+Install the latest version (3.5.1+) of R from [CRAN](https://cran.r-project.org/bin/windows/).
+You can [build MXNet-R from source](windows_setup.html#install-mxnet-package-for-r), or you can use a pre-built binary:
-```bash
-$ cd incubator-mxnet
-$ make rpkg
+```r
+cran <- getOption("repos")
+cran["dmlc"] <- "https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/R/CRAN/"
+options(repos = cran)
+install.packages("mxnet")
```
-</div> <!-- END of CPU -->
-
+</div> <!-- END - Windows R CPU -->
<div class="gpu">
+</br>
-The default version of R that is installed with `apt-get` is insufficient. You will need to first [install R v3.4.4+ and build MXNet from source](ubuntu_setup.html#install-the-mxnet-package-for-r).
-
-After you have setup R v3.4.4+ and MXNet, you can build and install the MXNet R bindings with the following, assuming that `incubator-mxnet` is the source directory you used to build MXNet as follows:
+You can [build MXNet-R from source](windows_setup.html#install-mxnet-package-for-r), or you can use a pre-built binary:
-```bash
-$ cd incubator-mxnet
-$ make rpkg
+```r
+ cran <- getOption("repos")
+ cran["dmlc"] <- "https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/R/CRAN/GPU/cu92"
+ options(repos = cran)
+ install.packages("mxnet")
```
+Change cu92 to cu80, cu90 or cu91 based on your CUDA toolkit version. Currently, MXNet supports these versions of CUDA.
</div> <!-- END of GPU -->
-</div> <!-- END of R -->
-
+</div> <!-- END - Windows R -->
<div class="scala">
-<div class="gpu">
-
-You can use the Maven packages defined in the following `dependency` to include MXNet in your Scala project. Please refer to the <a href="scala_setup.html">MXNet-Scala setup guide</a> for a detailed set of instructions to help you with the setup process.
-
-<a href="https://mvnrepository.com/artifact/org.apache.mxnet/mxnet-full_2.11-linux-x86_64-gpu"><img src="https://img.shields.io/badge/org.apache.mxnet-linux gpu-green.svg" alt="maven badge"/></a>
-
-```html
-<dependency>
- <groupId>org.apache.mxnet</groupId>
- <artifactId>mxnet-full_2.11-linux-x86_64-gpu</artifactId>
-</dependency>
-```
-<br>
-</div> <!-- End of gpu -->
-
-<div class="cpu">
-
-You can use the Maven packages defined in the following `dependency` to include MXNet in your Scala project. Please refer to the <a href="scala_setup.html">MXNet-Scala setup guide</a> for a detailed set of instructions to help you with the setup process.
-
-<a href="https://mvnrepository.com/artifact/org.apache.mxnet/mxnet-full_2.11-linux-x86_64-cpu"><img src="https://img.shields.io/badge/org.apache.mxnet-linux cpu-green.svg" alt="maven badge"/></a>
-
-```html
-<dependency>
- <groupId>org.apache.mxnet</groupId>
- <artifactId>mxnet-full_2.11-linux-x86_64-cpu</artifactId>
-</dependency>
-```
-<br>
-</div> <!-- End of cpu -->
+<div class="cpu gpu">
+<br/>
+MXNet-Scala for Windows is not yet available.
+<br/>
+</div> <!-- End of cpu gpu -->
</div> <!-- End of scala -->
-
-<div class="julia perl">
+<div class="julia">
<div class="cpu gpu">
-
-Follow the installation instructions [in this guide](./ubuntu_setup.md) to set up MXNet.
+</br>
+Refer to the <a href="windows_setup.html#install-the-mxnet-package-for-julia">Julia section of the MXNet Windows installation guide</a>.
</div> <!-- End of cpu gpu -->
-</div> <!-- End of julia perl -->
+</div> <!-- End of julia -->
+
+<div class="perl">
+<div class="cpu gpu">
+</br>
+Refer to the <a href="windows_setup.html#install-the-mxnet-package-for-perl">Perl section of the MXNet Windows installation guide</a>.
+</div> <!-- End of cpu gpu -->
+</div> <!-- End of julia -->
<div class="cpp">
<div class="cpu gpu">
-<p> To build the C++ package, please refer to <a href="build_from_source.html#build-the-c-package">this guide</a>. </p>
+</br>
+<p>To enable the C++ package, build from source using `make USE_CPP_PACKAGE=1`.
+<br/>Refer to the <a href="c_plus_plus.html">MXNet C++ setup guide</a> for more info.</p>
<br/>
</div> <!-- End of cpu gpu -->
-</div> <!-- END - C++-->
-</div> <!-- END - Linux -->
-
-
-<!-- START - MacOS Python CPU Installation Instructions -->
-
-<div class="macos">
-<div class="python">
-<div class="cpu">
-
-The following installation instructions have been tested on OSX Sierra and El Capitan.
+</div> <!-- End of C++ -->
+<hr>
+For more installation options, refer to the <a href="windows_setup.html">MXNet Windows installation guide</a>.
+</div> <!-- End of Windows -->
-<div class="pip">
-<br/>
+<!-- START - Cloud Python Installation Instructions -->
-**Step 1** Install prerequisites - Homebrew, python development tools.
+<div class="cloud">
-```bash
-# Install Homebrew
-$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
-$ export PATH=/usr/local/bin:/usr/local/sbin:$PATH
+AWS Marketplace distributes Deep Learning AMIs (Amazon Machine Image) with MXNet pre-installed. You can launch one of these Deep Learning AMIs by following instructions in the [AWS Deep Learning AMI Developer Guide](http://docs.aws.amazon.com/dlami/latest/devguide/what-is-dlami.html).
-# Install python development tools - python2.7, pip, python-setuptools
-$ brew install python
-```
+You can also run distributed deep learning with *MXNet* on AWS using [Cloudformation Template](https://github.com/awslabs/deeplearning-cfn/blob/master/README.md).
-**Step 2** Install MXNet with OpenBLAS acceleration.
+</div> <!-- END - Cloud Python Installation Instructions -->
-Installing *MXNet* with pip requires a latest version of `pip`. Install the latest version of `pip` by issuing the following command.
-```bash
-$ pip install --upgrade pip
-$ pip install --upgrade setuptools
-```
+<!-- DEVICES -->
+<div class="devices">
+ <div class="raspberry-pi">
-<div class="v1-2-1">
+MXNet supports the Debian based Raspbian ARM based operating system so you can run MXNet on Raspberry Pi Devices.
-Then use pip to install MXNet:
+These instructions will walk through how to build MXNet for the Raspberry Pi and install the Python bindings for the library.
-```bash
-$ pip install mxnet
-```
-</div> <!-- End of v1-2-1 -->
+You can do a dockerized cross compilation build on your local machine or a native build on-device.
+The complete MXNet library and its requirements can take almost 200MB of RAM, and loading large models with the library can take over 1GB of RAM. Because of this, we recommend running MXNet on the Raspberry Pi 3 or an equivalent device that has more than 1 GB of RAM and a Secure Digital (SD) card that has at least 4 GB of free memory.
-<div class="v1-1-0">
+**Cross compilation build (Experimental)**
-Then use pip to install MXNet:
+## Docker installation
+**Step 1** Install Docker on your machine by following the [docker installation instructions](https://docs.docker.com/engine/installation/linux/ubuntu/#install-using-the-repository).
-```bash
-$ pip install mxnet==1.1.0
-```
+*Note* - You can install Community Edition (CE)
-</div> <!-- End of v1-1-0-->
+**Step 2** [Optional] Post installation steps to manage Docker as a non-root user.
+Follow the four steps in this [docker documentation](https://docs.docker.com/engine/installation/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow managing docker containers without *sudo*.
-<div class="v1-0-0">
+## Build
-Then use pip to install MXNet:
+The following command will build a container with dependencies and tools and then compile MXNet for
+ARMv7. The resulting artifact will be located in `build/mxnet-x.x.x-py2.py3-none-any.whl`, copy this
+file to your Raspberry Pi.
-```bash
-$ pip install mxnet==1.0.0
+```
+ci/build.py -p armv7
```
-</div> <!-- End of v1-0-0-->
-
-<div class="v0-12-1">
+## Install
-Then use pip to install MXNet:
+Create a virtualenv and install the package we created previously.
-```bash
-$ pip install mxnet=0.12.1
```
-
-For MXNet 0.12.0 -
-
-```bash
-$ pip install mxnet=0.12.0
+virtualenv -p `which python3` mxnet_py3
+source mxnet_py3/bin/activate
+pip install mxnet-x.x.x-py2.py3-none-any.whl
```
-</div> <!-- End of v0-12-1-->
-
-
-<div class="v0-11-0">
-
-Then use pip to install MXNet:
-
-```bash
-$ pip install mxnet==0.11.0
-```
+**Native Build**
-</div> <!-- End of v0-11-0-->
+Installing MXNet is a two-step process:
-<div class="master">
+1. Build the shared library from the MXNet C++ source code.
+2. Install the supported language-specific packages for MXNet.
-Then use pip to install MXNet:
+**Step 1** Build the Shared Library
-```bash
-$ pip install mxnet --pre
-```
+On Raspbian versions Wheezy and later, you need the following dependencies:
-</div> <!-- End of master-->
+- Git (to pull code from GitHub)
-**Step 3** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-$ brew install graphviz
-$ pip install graphviz
-```
+- libblas (for linear algebraic operations)
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
+- libopencv (for computer vision operations. This is optional if you want to save RAM and Disk Space)
-</div> <!-- END of pip -->
+- A C++ compiler that supports C++ 11. The C++ compiler compiles and builds MXNet source code. Supported compilers include the following:
+ - [G++ (4.8 or later)](https://gcc.gnu.org/gcc-4.8/). Make sure to use gcc 4 and not 5 or 6 as there are known bugs with these compilers.
+ - [Clang (3.9 - 6)](https://clang.llvm.org/)
-<div class="virtualenv">
-<br/>
+Install these dependencies using the following commands in any directory:
-**Step 1** Install prerequisites - Homebrew, python development tools.
+```
+ sudo apt-get update
+ sudo apt-get -y install git cmake ninja-build build-essential g++-4.9 c++-4.9 liblapack* libblas* libopencv* libopenblas* python3-dev virtualenv
+```
-```bash
-# Install Homebrew
-$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
-$ export PATH=/usr/local/bin:/usr/local/sbin:$PATH
+Clone the MXNet source code repository using the following `git` command in your home directory:
+```
+ git clone https://github.com/apache/incubator-mxnet.git --recursive
+ cd incubator-mxnet
+```
-# Install python development tools - python2.7, pip, python-setuptools
-$ brew install python
+Build:
+```
+ mkdir -p build && cd build
+ cmake \
+ -DUSE_SSE=OFF \
+ -DUSE_CUDA=OFF \
+ -DUSE_OPENCV=ON \
+ -DUSE_OPENMP=ON \
+ -DUSE_MKL_IF_AVAILABLE=OFF \
+ -DUSE_SIGNAL_HANDLER=ON \
+ -DCMAKE_BUILD_TYPE=Release \
+ -GNinja ..
+ ninja -j$(nproc)
```
+Some compilation units require memory close to 1GB, so it's recommended that you enable swap as
+explained below and be cautious about increasing the number of jobs when building (-j)
-**Step 2** Install virtualenv for macOS.
+Executing these commands start the build process, which can take up to a couple hours, and creates a file called `libmxnet.so` in the build directory.
-```bash
-$ pip install virtualenv
+If you are getting build errors in which the compiler is being killed, it is likely that the
+compiler is running out of memory (especially if you are on Raspberry Pi 1, 2 or Zero, which have
+less than 1GB of RAM), this can often be rectified by increasing the swapfile size on the Pi by
+editing the file /etc/dphys-swapfile and changing the line CONF_SWAPSIZE=100 to CONF_SWAPSIZE=1024,
+then running:
+```
+ sudo /etc/init.d/dphys-swapfile stop
+ sudo /etc/init.d/dphys-swapfile start
+ free -m # to verify the swapfile size has been increased
```
-**Step 3** Create and activate virtualenv environment for MXNet.
+**Step 2** Install MXNet Python Bindings
-Following command creates a virtualenv environment at `~/mxnet` directory. However, you can choose any directory by replacing `~/mxnet` with a directory of your choice.
+To install Python bindings run the following commands in the MXNet directory:
-```bash
-$ virtualenv --system-site-packages ~/mxnet
```
-
-Activate the virtualenv environment created for *MXNet*.
-
-```bash
-$ source ~/mxnet/bin/activate
+ cd python
+ pip install --upgrade pip
+ pip install -e .
```
-After activating the environment, you should see the prompt as below.
+Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
-```bash
-(mxnet)$
+Alternatively you can create a whl package installable with pip with the following command:
+```
+ci/docker/runtime_functions.sh build_wheel python/ $(realpath build)
```
-**Step 4** Install MXNet in the active virtualenv environment.
-Installing *MXNet* with pip requires a latest version of `pip`. Install the latest version of `pip` by issuing the following command.
+You are now ready to run MXNet on your Raspberry Pi device. You can get started by following the tutorial on [Real-time Object Detection with MXNet On The Raspberry Pi](http://mxnet.io/tutorials/embedded/wine_detector.html).
-```bash
-(mxnet)$ pip install --upgrade pip
-(mxnet)$ pip install --upgrade setuptools
-```
+*Note - Because the complete MXNet library takes up a significant amount of the Raspberry Pi's limited RAM, when loading training data or large models into memory, you might have to turn off the GUI and terminate running processes to free RAM.*
-<div class="v1-2-1">
+</div> <!-- End of raspberry pi -->
-Install *MXNet* with OpenBLAS acceleration.
-```bash
-(mxnet)$ pip install mxnet
-```
+<div class="nvidia-jetson">
-</div> <!-- End of v1-2-1-->
+# Nvidia Jetson TX family
-<div class="v1-1-0">
+MXNet supports the Ubuntu Arch64 based operating system so you can run MXNet on NVIDIA Jetson Devices.
-Install *MXNet* with OpenBLAS acceleration.
+These instructions will walk through how to build MXNet for the Pascal based [NVIDIA Jetson TX2](http://www.nvidia.com/object/embedded-systems-dev-kits-modules.html) and install the corresponding python language bindings.
-```bash
-(mxnet)$ pip install mxnet==1.1.0
-```
+For the purposes of this install guide we will assume that CUDA is already installed on your Jetson device.
-</div> <!-- End of v1-1-0-->
+**Install MXNet**
-<div class="v1-0-0">
+Installing MXNet is a two-step process:
-Install *MXNet* with OpenBLAS acceleration.
+1. Build the shared library from the MXNet C++ source code.
+2. Install the supported language-specific packages for MXNet.
-```bash
-(mxnet)$ pip install mxnet==1.0.0
-```
+**Step 1** Build the Shared Library
-</div> <!-- End of v1-0-0-->
+You need the following additional dependencies:
+- Git (to pull code from GitHub)
-<div class="v0-12-1">
+- libatlas (for linear algebraic operations)
-Install *MXNet* with OpenBLAS acceleration.
+- libopencv (for computer vision operations)
-```bash
-(mxnet)$ pip install mxnet==0.12.1
-```
+- python pip (to load relevant python packages for our language bindings)
-For *MXNet* 0.12.0 -
+Install these dependencies using the following commands in any directory:
-```bash
-(mxnet)$ pip install mxnet==0.12.0
+```
+ sudo apt-get update
+ sudo apt-get -y install git build-essential libatlas-base-dev libopencv-dev graphviz python-pip
+ sudo pip install pip --upgrade
+ sudo pip install setuptools numpy --upgrade
+ sudo pip install graphviz jupyter
```
+Clone the MXNet source code repository using the following `git` command in your home directory:
+```
+ git clone https://github.com/apache/incubator-mxnet.git --recursive
+ cd incubator-mxnet
+```
-</div> <!-- End of v0-12-1-->
-
-<div class="v0-11-0">
+Edit the Makefile to install the MXNet with CUDA bindings to leverage the GPU on the Jetson:
+```
+ cp make/crosscompile.jetson.mk config.mk
+```
-Install *MXNet* with OpenBLAS acceleration.
+Edit the Mshadow Makefile to ensure MXNet builds with Pascal's hardware level low precision acceleration by editing 3rdparty/mshadow/make/mshadow.mk and adding the following after line 122:
+```
+MSHADOW_CFLAGS += -DMSHADOW_USE_PASCAL=1
+```
-```bash
-(mxnet)$ pip install mxnet==0.11.0
+Now you can build the complete MXNet library with the following command:
+```
+ make -j $(nproc)
```
-</div> <!-- End of v0-11-0-->
+Executing this command creates a file called `libmxnet.so` in the mxnet/lib directory.
-<div class="master">
+**Step 2** Install MXNet Python Bindings
-Install *MXNet* with OpenBLAS acceleration.
+To install Python bindings run the following commands in the MXNet directory:
-```bash
-(mxnet)$ pip install mxnet --pre
```
-
-</div> <!-- End of master-->
-
-
-**Step 5** Install [Graphviz](http://www.graphviz.org/). (Optional, needed for graph visualization using `mxnet.viz` package).
-```bash
-$ brew install graphviz
-(mxnet)$ pip install graphviz
+ cd python
+ pip install --upgrade pip
+ pip install -e .
```
-**Step 6** Validate the installation by running simple *MXNet* code described [here](#validate-mxnet-installation).
-
-**Note** You can read more about virtualenv [here](https://virtualenv.pypa.io/en/stable/userguide/).
+Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
-</div> <!-- End of virtualenv -->
+Add the mxnet folder to the path:
+```
+ cd ..
+ export MXNET_HOME=$(pwd)
+ echo "export PYTHONPATH=$MXNET_HOME/python:$PYTHONPATH" >> ~/.rc
+ source ~/.rc
+```
-<div class="docker">
-<br/>
+You are now ready to run MXNet on your NVIDIA Jetson TX2 device.
-Docker images with *MXNet* are available at [Docker Hub](https://hub.docker.com/r/mxnet/).
+</div> <!-- End of jetson -->
+</div> <!-- End of devices -->
-**Step 1** Install Docker on your machine by following the [docker installation instructions](https://docs.docker.com/docker-for-mac/install/#install-and-run-docker-for-mac).
-*Note* - You can install Community Edition (CE) to get started with *MXNet*.
+<!-- This # tag restarts the page and allows reuse
+ of the div classes for validation sections, etc -->
-**Step 2** Pull the MXNet docker image.
-```bash
-$ docker pull mxnet/python
-```
-
-You can list docker images to see if mxnet/python docker image pull was successful.
-
-```bash
-$ docker images
-
-REPOSITORY TAG IMAGE ID CREATED SIZE
-mxnet/python latest 00d026968b3c 3 weeks ago 1.41 GB
-```
-
-**Step 4** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
-
-</div> <!-- END of docker -->
-
-
-<div class="build-from-source">
-<br/>
-
-**Prerequisites**
-
-If not already installed, [download and install Xcode](https://developer.apple.com/xcode/) (or [insall it from the App Store](https://itunes.apple.com/us/app/xcode/id497799835)) for macOS. [Xcode](https://en.wikipedia.org/wiki/Xcode) is an integrated development environment for macOS containing a suite of software development tools like C/C++ compilers, BLAS library and more.
-
-<br/>
-
-Building *MXNet* from source is a 2 step process.
-1. Build the *MXNet* core shared library, `libmxnet.so`, from the C++ sources.
-2. Build the language specific bindings. Example - Python bindings, Scala bindings.
-
-Make sure you have installed Xcode before proceeding further.
-
-<br/>
-
-All the instructions to build *MXNet* core shared library and *MXNet* Python bindings are compiled as one helper *bash* script. You can use [this bash script](https://raw.githubusercontent.com/dmlc/mxnet/master/setup-utils/install-mxnet-osx-python.sh) to build *MXNet* for Python, from source, on macOS.
-
-**Step 1** Download the bash script for building MXNet from source.
-
-```bash
-$ curl -O https://raw.githubusercontent.com/dmlc/mxnet/master/setup-utils/install-mxnet-osx-python.sh
-```
-
-**Step 2** Run the script to get latest MXNet source and build.
-
-```bash
-# Make the script executable
-$ chmod 744 install-mxnet-osx-python.sh
-
-# Run the script. It takes around 5 mins.
-$ bash install-mxnet-osx-python.sh
-```
-
-**Step 3** Validate the installation by running simple MXNet code described [here](#validate-mxnet-installation).
-
-</div> <!-- END of build from source -->
-</div> <!-- END of CPU -->
-
-
-<!-- START - Mac OS Python GPU Installation Instructions -->
-<div class="gpu">
-<div class="pip virtualenv docker">
-</br>
-
-Try the **Build from Source** option for now.
-
-</div>
-
-<div class="build-from-source">
-
-**Step 1** Install prerequisites - Homebrew, python development tools.
-
-```bash
-# Install Homebrew
-$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
-$ export PATH=/usr/local/bin:/usr/local/sbin:$PATH
-
-# Install python development tools - python2.7, pip, python-setuptools
-$ brew install python pkg-config graphviz
-```
-
-**Step 2** Install optional components - OpenCV
-
-If you want to use OpenCV you should install it first, then build MXNet with the `USE_OPENCV=1` option in the later steps.
-
-```bash
-brew tap homebrew/science
-brew install opencv
-
-```
-
-**Step 3** Install CUDA and cuDNN
-
-The following instructions are for CUDA 9.1 and cuDNN 7 for macOS 10.12+ and a CUDA-capable GPU. They summarize confirmed successful builds in [#9217](https://github.com/apache/incubator-mxnet/issues/9217).
-Alternatively, you may follow the [CUDA installation instructions for macOS](https://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html).
-
-1. [Download Xcode 8.3.3 from Apple](https://developer.apple.com/download/more/). This is the version [NVIDIA specifies in its instructions for macOS](https://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html). Unzip and rename to `Xcode8.3.3.app`.
-
-2. Run `sudo xcode-select -s /Applications/Xcode8.3.3.app` or to wherever you have placed Xcode.
-
-3. Run `xcode-select --install` to install all command line tools, compilers, etc.
-
-4. Run `sudo xcodebuild -license accept` to accept Xcode's licensing terms.
-
-5. Install CUDA for macOS. Specific steps are provided in NVIDIA's [CUDA installation instructions](https://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x/index.html#installation).
-
-6. [Download](http://docs.nvidia.com/deeplearning/sdk/cudnn-install/index.html#download-mac) and [install](http://docs.nvidia.com/deeplearning/sdk/cudnn-install/index.html#installmac) cuDNN for macOS. You will need to [create a free developer account](https://developer.nvidia.com/accelerated-computing-developer) with NVIDIA prior to getting the download link.
-
-**Step 4** Build MXNet
-
-1. Run `git clone --recursive https://github.com/apache/incubator-mxnet.git mxnet` to get the latest version.
-
-2. Run `cd mxnet`.
-
-3. Edit the `make/osx.mk` file to set the following parameters:
-
- ```
- USE_CUDA = 1
- USE_CUDA_PATH = /usr/local/cuda
- USE_CUDNN = 1
- USE_OPENCV = 0 # set to 1 if you want to build with OpenCV
- ```
-
-4. Copy the `make/osx.mk` to `config.mk`
-
-5. Run `make`. If you previously attempted to compile you might want to do `make clean_all` first. You can also run `make -j` with the number of processors you have to compile with multithreading. There'll be plenty of warnings, but there should be no errors.
-
-6. Once finished, you should have a file called `libmxnet.so` in `lib/`.
-
-7. Do `cd python`.
-
-8. Run `sudo pip install -e .` **Note**: the `.` is part of the command.
-
-</div> <!-- END of build from source -->
-</div> <!-- END of GPU -->
-</div> <!-- END of Python -->
-
-
-<!-- START - MacOS R CPU Installation Instructions -->
-
-<div class="r">
-<div class="cpu">
-
-Install the latest version (3.5.1+) of R from [CRAN](https://cran.r-project.org/bin/macosx/).
-You can [build MXNet-R from source](osx_setup.html#install-the-mxnet-package-for-r), or you can use a pre-built binary:
-
-```r
-cran <- getOption("repos")
-cran["dmlc"] <- "https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/R/CRAN/"
-options(repos = cran)
-install.packages("mxnet")
-```
-
-</div> <!-- END of CPU -->
-
-
-<div class="gpu">
-
-Will be available soon.
-
-</div> <!-- END of GPU -->
-</div> <!-- END of R -->
-
-<div class="scala">
-<div class="cpu">
-
-You can use the Maven packages defined in the following `dependency` to include MXNet in your Scala project. Please refer to the <a href="scala_setup.html">MXNet-Scala setup guide</a> for a detailed set of instructions to help you with the setup process.
-
-<a href="https://mvnrepository.com/artifact/org.apache.mxnet/mxnet-full_2.11-osx-x86_64-cpu"><img src="https://img.shields.io/badge/org.apache.mxnet-mac cpu-green.svg" alt="maven badge"/></a>
-
-```html
-<dependency>
- <groupId>org.apache.mxnet</groupId>
- <artifactId>mxnet-full_2.11-osx-x86_64-cpu</artifactId>
-</dependency>
-```
-<br>
-</div> <!-- End of cpu -->
-<div class="gpu">
-
-Not available at this time. <br>
-
-</div>
-</div> <!-- End of scala -->
-
-
-<div class="julia perl">
-<div class="cpu gpu">
-
-Follow the installation instructions [in this guide](./osx_setup.md) to set up MXNet.
-
-</div> <!-- End of cpu gpu -->
-</div> <!-- End of julia perl -->
-
-
-<div class="cpp">
-<p>To build the C++ package, please refer to <a href="build_from_source.html#build-the-c-package">this guide</a>.</p>
-<br/>
-</div>
-</div> <!-- END - Mac OS -->
-
-
-
-
-
-
-
-
-
-<div class="windows">
-<div class="python">
-<div class="cpu">
-<div class="pip">
-
-<br/>
-
-**Step 1** Install Python.
-
-[Anaconda](https://www.anaconda.com/download/) is recommended.
-
-<div class="v1-2-1">
-
-**Step 2** Install *MXNet*.
-
-```bash
-$ pip install mxnet
-```
-
-</div> <!-- End of v1-2-1-->
-
-<div class="v1-1-0">
-
-**Step 2** Install *MXNet*.
-
-```bash
-$ pip install mxnet==1.1.0
-```
-
-</div> <!-- End of v1-1-0-->
-
-<div class="v1-0-0">
-
-**Step 2** Install *MXNet*.
-
-```bash
-$ pip install mxnet==1.0.0
-```
-
-</div> <!-- End of v1-0-0-->
-
-
-<div class="v0-12-1">
-
-**Step 2** Install *MXNet*.
-
-```bash
-$ pip install mxnet==0.12.1
-```
-
-For *MXNet* 0.12.0 -
-
-```bash
-$ pip install mxnet==0.12.0
-```
-
-
-</div> <!-- End of v0-12-1-->
-
-<div class="v0-11-0">
-
-**Step 2** Install *MXNet*.
-
-```bash
-$ pip install mxnet==0.11.0
-```
-
-
-</div> <!-- End of v0-11-0-->
-
-<div class="master">
-
-**Step 2** Install *MXNet*.
-
-```bash
-$ pip install mxnet --pre
-```
-
-</div> <!-- End of master-->
-
-
-</div> <!-- End of pip -->
-
-
-<div class="virtualenv docker build-from-source">
-
-Follow the installation instructions [in this guide](./windows_setup.md) to set up MXNet.
-
-</div> <!-- End of virtualenv docker build-from-source -->
-</div> <!-- End of CPU -->
-
-
-<div class="gpu">
-<div class="pip">
-
-<br/>
-
-**Step 1** Install Python.
-
-[Anaconda](https://www.anaconda.com/download/) is recommended.
-
-
-<div class="v1-2-1">
-
-**Step 2** Install *MXNet* with GPU support using CUDA 9.2.
-
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
-
-```bash
-nvcc --version
-```
-
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
-
-```bash
-$ pip install mxnet-cu92
-```
-
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
-
-</div> <!-- End of v1-2-1-->
-
-<div class="v1-1-0">
-
-**Step 2** Install *MXNet* with GPU support using CUDA 9.1.
-
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
-
-```bash
-nvcc --version
-```
-
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
-
-```bash
-$ pip install mxnet-cu91==1.1.0
-```
-
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
-
-</div> <!-- End of v1-1-0-->
-
-<div class="v1-0-0">
-
-**Step 2** Install *MXNet* with GPU support using CUDA 9.0.
-
-```bash
-$ pip install mxnet-cu90==1.0.0
-```
-
-</div> <!-- End of v1-0-0-->
-
-<div class="v0-12-1">
-
-**Step 2** Install *MXNet* with GPU support using CUDA 9.0.
-
-```bash
-$ pip install mxnet-cu90==0.12.1
-```
-
-Install *MXNet* 0.12.0 with GPU support using CUDA 9.0.
-
-```bash
-$ pip install mxnet-cu90==0.12.0
-```
-
-</div> <!-- End of v0-12-1-->
-
-<div class="v0-11-0">
-
-**Step 2** Install *MXNet* with GPU support using CUDA 8.0.
-
-```bash
-$ pip install mxnet-cu80==0.11.0
-```
-
-</div> <!-- End of v0-11-0-->
-
-<div class="master">
-
-**Step 2** Install *MXNet* with GPU support using CUDA 9.2.
-
-**Important**: Make sure your installed CUDA version matches the CUDA version in the pip package.
-Check your CUDA version with the following command:
-
-```bash
-nvcc --version
-```
-
-You can either upgrade your CUDA install or install the MXNet package that supports your CUDA version.
-
-```bash
-$ pip install mxnet-cu92 --pre
-```
-
-Refer to [pypi for older packages](https://pypi.org/project/mxnet/).
-
-</div> <!-- End of master-->
-
-Refer to [#8671](https://github.com/apache/incubator-mxnet/issues/8671) for status on CUDA 9.1 support.
-
-</div>
-<div class="build-from-source">
-<br/>
-
-We provide both options to build and install MXNet yourself using [Microsoft Visual Studio 2017](https://www.visualstudio.com/downloads/), and [Microsoft Visual Studio 2015](https://www.visualstudio.com/vs/older-downloads/).
-
-**Option 1**
-
-To build and install MXNet yourself using [Microsoft Visual Studio 2017](https://www.visualstudio.com/downloads/), you need the following dependencies. Install the required dependencies:
-
-1. If [Microsoft Visual Studio 2017](https://www.visualstudio.com/downloads/) is not already installed, download and install it. You can download and install the free community edition.
-2. Download and install [CMake](https://cmake.org/files/v3.11/cmake-3.11.0-rc4-win64-x64.msi) if it is not already installed.
-3. Download and install [OpenCV](https://sourceforge.net/projects/opencvlibrary/files/opencv-win/3.4.1/opencv-3.4.1-vc14_vc15.exe/download).
-4. Unzip the OpenCV package.
-5. Set the environment variable ```OpenCV_DIR``` to point to the ```OpenCV build directory``` (e.g., ```OpenCV_DIR = C:\utils\opencv\build```).
-6. If you don’t have the Intel Math Kernel Library (MKL) installed, download and install [OpenBlas](https://sourceforge.net/projects/openblas/files/v0.2.20/OpenBLAS%200.2.20%20version.zip/download).
-7. Set the environment variable ```OpenBLAS_HOME``` to point to the ```OpenBLAS``` directory that contains the ```include``` and ```lib``` directories (e.g., ```OpenBLAS_HOME = C:\utils\OpenBLAS```).
-8. Download and install CUDA: Install [CUDA](https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exelocal), and Download the base installer (e.g., ```cuda_9.1.85_win10.exe```).
-9. Download and install cuDNN. To get access to the download link, register as an NVIDIA community user. Then Follow the [link](http://docs.nvidia.com/deeplearning/sdk/cudnn-install/index.html#install-windows) to install the cuDNN.
-10. Download and install [git](https://git-for-windows.github.io/).
-
-After you have installed all of the required dependencies, build the MXNet source code:
-
-1. Start ```cmd``` in windows.
-
-2. Download the MXNet source code from GitHub by using following command:
-
-```r
-cd C:\
-git clone https://github.com/apache/incubator-mxnet.git --recursive
-```
-
-3. Follow [this link](https://docs.microsoft.com/en-us/visualstudio/install/modify-visual-studio) to modify ```Individual components```, and check ```VC++ 2017 version 15.4 v14.11 toolset```, and click ```Modify```.
-
-4. Change the version of the Visual studio 2017 to v14.11 using the following command (by default the VS2017 is installed in the following path):
-
-```r
-"C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat" -vcvars_ver=14.11
-```
-
-5. Create a build dir using the following command and go to the directory, for example:
-
-```r
-mkdir C:\build
-cd C:\build
-```
-
-6. CMake the MXNet source code by using following command:
-
-```r
-cmake -G "Visual Studio 15 2017 Win64" -T cuda=9.1,host=x64 -DUSE_CUDA=1 -DUSE_CUDNN=1 -DUSE_NVRTC=1 -DUSE_OPENCV=1 -DUSE_OPENMP=1 -DUSE_BLAS=open -DUSE_LAPACK=1 -DUSE_DIST_KVSTORE=0 -DCUDA_ARCH_LIST=Common -DCUDA_TOOLSET=9.1 -DCUDNN_INCLUDE=C:\cuda\include -DCUDNN_LIBRARY=C:\cuda\lib\x64\cudnn.lib "C:\incubator-mxnet"
-```
-
-NOTE: make sure the DCUDNN_INCLUDE and DCUDNN_LIBRARY pointing to the “include” and “cudnn.lib” of your CUDA installed location, and the ```C:\incubator-mxnet``` is the location of the source code you just git in the previous step
-
-7. After the CMake successfully completed, compile the the MXNet source code by using following command:
-
-```r
-msbuild mxnet.sln /p:Configuration=Release;Platform=x64 /maxcpucount
-```
-
-**Option 2**
-
-To build and install MXNet yourself using [Microsoft Visual Studio 2015](https://www.visualstudio.com/vs/older-downloads/), you need the following dependencies. Install the required dependencies:
-
-1. If [Microsoft Visual Studio 2015](https://www.visualstudio.com/vs/older-downloads/) is not already installed, download and install it. You can download and install the free community edition. At least Update 3 of Microsoft Visual Studio 2015 is required to build MXNet from source. Upgrade via it's ```Tools -> Extensions and Updates... | Product Updates``` menu.
-2. Download and install [CMake](https://cmake.org/) if it is not already installed.
-3. Download and install [OpenCV](http://sourceforge.net/projects/opencvlibrary/files/opencv-win/3.0.0/opencv-3.0.0.exe/download).
-4. Unzip the OpenCV package.
-5. Set the environment variable ```OpenCV_DIR``` to point to the ```OpenCV build directory``` (```C:\opencv\build\x64\vc14``` for example). Also, you need to add the OpenCV bin directory (```C:\opencv\build\x64\vc14\bin``` for example) to the ``PATH`` variable.
-6. If you don't have the Intel Math Kernel Library (MKL) installed, download and install [OpenBlas](http://sourceforge.net/projects/openblas/files/v0.2.14/).
-7. Set the environment variable ```OpenBLAS_HOME``` to point to the ```OpenBLAS``` directory that contains the ```include``` and ```lib``` directories. Typically, you can find the directory in ```C:\Program files (x86)\OpenBLAS\```.
-8. Download and install [CUDA](https://developer.nvidia.com/cuda-downloads?target_os=Windows&target_arch=x86_64) and [cuDNN](https://developer.nvidia.com/cudnn). To get access to the download link, register as an NVIDIA community user.
-9. Set the environment variable ```CUDACXX``` to point to the ```CUDA Compiler```(```C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.1\bin\nvcc.exe``` for example).
-10. Set the environment variable ```CUDNN_ROOT``` to point to the ```cuDNN``` directory that contains the ```include```, ```lib``` and ```bin``` directories (```C:\Downloads\cudnn-9.1-windows7-x64-v7\cuda``` for example).
-
-After you have installed all of the required dependencies, build the MXNet source code:
-
-1. Download the MXNet source code from [GitHub](https://github.com/apache/incubator-mxnet) (make sure you also download third parties submodules e.g. ```git clone --recurse-submodules```).
-2. Use [CMake](https://cmake.org/) to create a Visual Studio solution in ```./build```.
-3. In Visual Studio, open the solution file,```.sln```, and compile it.
-These commands produce a library called ```mxnet.dll``` in the ```./build/Release/``` or ```./build/Debug``` folder.
-
-
-Next, we install the ```graphviz``` library that we use for visualizing network graphs that you build on MXNet. We will also install [Jupyter Notebook](http://jupyter.readthedocs.io/) which is used for running MXNet tutorials and examples.
-- Install the ```graphviz``` by downloading the installer from the [Graphviz Download Page](https://graphviz.gitlab.io/_pages/Download/Download_windows.html).
-**Note** Make sure to add the `graphviz` executable path to the PATH environment variable. Refer [here for more details](http://stackoverflow.com/questions/35064304/runtimeerror-make-sure-the-graphviz-executables-are-on-your-systems-path-aft)
-
-
-
-</div> <!-- End of pip -->
-</div> <!-- End of GPU -->
-</div> <!-- End of Python -->
-
-
-<!-- START - Windows R CPU Installation Instructions -->
-
-<div class="r">
-<div class="cpu">
-
-Install the latest version (3.5.1+) of R from [CRAN](https://cran.r-project.org/bin/windows/).
-You can [build MXNet-R from source](windows_setup.html#install-mxnet-package-for-r), or you can use a pre-built binary:
-
-```r
-cran <- getOption("repos")
-cran["dmlc"] <- "https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/R/CRAN/"
-options(repos = cran)
-install.packages("mxnet")
-```
-
-</div> <!-- END - Windows R CPU -->
-
-<div class="gpu">
-
-You can [build MXNet-R from source](windows_setup.html#install-mxnet-package-for-r), or you can use a pre-built binary:
-
-```r
- cran <- getOption("repos")
- cran["dmlc"] <- "https://apache-mxnet.s3-accelerate.dualstack.amazonaws.com/R/CRAN/GPU/cu92"
- options(repos = cran)
- install.packages("mxnet")
-```
-Change cu92 to cu80, cu90 or cu91 based on your CUDA toolkit version. Currently, MXNet supports these versions of CUDA.
-
-</div> <!-- END of GPU -->
-</div> <!-- END - Windows R -->
-
-<div class="scala">
-<div class="cpu gpu">
-
-MXNet-Scala for Windows is not yet available.
-<br>
-</div> <!-- End of cpu gpu -->
-</div> <!-- End of scala -->
-
-<div class="julia perl">
-<div class="cpu gpu">
-
-Follow the installation instructions [in this guide](./windows_setup.md) to set up MXNet.
-
-</div> <!-- End of cpu gpu -->
-</div> <!-- End of julia perl -->
-
-<div class="cpp">
-<div class="cpu gpu">
-<p> To build the C++ package, please refer to <a href="build_from_source.html#build-the-c-package">this guide</a>. </p>
-<br/>
-</div> <!-- End of cpu gpu -->
-</div> <!-- End of C++ -->
-</div> <!-- End of Windows -->
-
-
-<!-- START - Cloud Python Installation Instructions -->
-
-<div class="cloud">
-
-AWS Marketplace distributes Deep Learning AMIs (Amazon Machine Image) with MXNet pre-installed. You can launch one of these Deep Learning AMIs by following instructions in the [AWS Deep Learning AMI Developer Guide](http://docs.aws.amazon.com/dlami/latest/devguide/what-is-dlami.html).
-
-You can also run distributed deep learning with *MXNet* on AWS using [Cloudformation Template](https://github.com/awslabs/deeplearning-cfn/blob/master/README.md).
-
-</div> <!-- END - Cloud Python Installation Instructions -->
-
-
-<!-- DEVICES -->
-<div class="devices">
- <div class="raspberry-pi">
-
-MXNet supports the Debian based Raspbian ARM based operating system so you can run MXNet on Raspberry Pi Devices.
-
-These instructions will walk through how to build MXNet for the Raspberry Pi and install the Python bindings for the library.
-
-You can do a dockerized cross compilation build on your local machine or a native build on-device.
-
-The complete MXNet library and its requirements can take almost 200MB of RAM, and loading large models with the library can take over 1GB of RAM. Because of this, we recommend running MXNet on the Raspberry Pi 3 or an equivalent device that has more than 1 GB of RAM and a Secure Digital (SD) card that has at least 4 GB of free memory.
-
-**Cross compilation build (Experimental)**
-
-## Docker installation
-**Step 1** Install Docker on your machine by following the [docker installation instructions](https://docs.docker.com/engine/installation/linux/ubuntu/#install-using-the-repository).
-
-*Note* - You can install Community Edition (CE)
-
-**Step 2** [Optional] Post installation steps to manage Docker as a non-root user.
-
-Follow the four steps in this [docker documentation](https://docs.docker.com/engine/installation/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow managing docker containers without *sudo*.
-
-## Build
-
-The following command will build a container with dependencies and tools and then compile MXNet for
-ARMv7. The resulting artifact will be located in `build/mxnet-x.x.x-py2.py3-none-any.whl`, copy this
-file to your Raspberry Pi.
-
-```bash
-ci/build.py -p armv7
-```
-
-## Install
-
-Create a virtualenv and install the package we created previously.
-
-```bash
-virtualenv -p `which python3` mxnet_py3
-source mxnet_py3/bin/activate
-pip install mxnet-x.x.x-py2.py3-none-any.whl
-```
-
-
-**Native Build**
-
-Installing MXNet is a two-step process:
-
-1. Build the shared library from the MXNet C++ source code.
-2. Install the supported language-specific packages for MXNet.
-
-**Step 1** Build the Shared Library
-
-On Raspbian versions Wheezy and later, you need the following dependencies:
-
-- Git (to pull code from GitHub)
-
-- libblas (for linear algebraic operations)
-
-- libopencv (for computer vision operations. This is optional if you want to save RAM and Disk Space)
-
-- A C++ compiler that supports C++ 11. The C++ compiler compiles and builds MXNet source code. Supported compilers include the following:
-
-- [G++ (4.8 or later)](https://gcc.gnu.org/gcc-4.8/). Make sure to use gcc 4 and not 5 or 6 as there
- are known bugs with these compilers.
-
-Install these dependencies using the following commands in any directory:
-
-```bash
- sudo apt-get update
- sudo apt-get -y install git cmake ninja-build build-essential g++-4.9 c++-4.9 liblapack* libblas* libopencv* libopenblas* python3-dev virtualenv
-```
-
-Clone the MXNet source code repository using the following `git` command in your home directory:
-```bash
- git clone https://github.com/apache/incubator-mxnet.git --recursive
- cd incubator-mxnet
-```
-
-Build:
-```bash
- mkdir -p build && cd build
- cmake \
- -DUSE_SSE=OFF \
- -DUSE_CUDA=OFF \
- -DUSE_OPENCV=ON \
- -DUSE_OPENMP=ON \
- -DUSE_MKL_IF_AVAILABLE=OFF \
- -DUSE_SIGNAL_HANDLER=ON \
- -DCMAKE_BUILD_TYPE=Release \
- -GNinja ..
- ninja -j1
-```
-Some compilation units require memory close to 1GB, so it's recommended that you enable swap as
-explained below and be cautious about increasing the number of jobs when building (-j)
-
-Executing these commands start the build process, which can take up to a couple hours, and creates a file called `libmxnet.so` in the build directory.
-
-If you are getting build errors in which the compiler is being killed, it is likely that the
-compiler is running out of memory (especially if you are on Raspberry Pi 1, 2 or Zero, which have
-less than 1GB of RAM), this can often be rectified by increasing the swapfile size on the Pi by
-editing the file /etc/dphys-swapfile and changing the line CONF_SWAPSIZE=100 to CONF_SWAPSIZE=1024,
-then running:
-```bash
- sudo /etc/init.d/dphys-swapfile stop
- sudo /etc/init.d/dphys-swapfile start
- free -m # to verify the swapfile size has been increased
-```
-
-**Step 2** Install MXNet Python Bindings
-
-To install Python bindings run the following commands in the MXNet directory:
-
-```bash
- cd python
- pip install --upgrade pip
- pip install -e .
-```
-
-Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
-
-Alternatively you can create a whl package installable with pip with the following command:
-```bash
-ci/docker/runtime_functions.sh build_wheel python/ $(realpath build)
-```
-
-
-You are now ready to run MXNet on your Raspberry Pi device. You can get started by following the tutorial on [Real-time Object Detection with MXNet On The Raspberry Pi](http://mxnet.io/tutorials/embedded/wine_detector.html).
-
-*Note - Because the complete MXNet library takes up a significant amount of the Raspberry Pi's limited RAM, when loading training data or large models into memory, you might have to turn off the GUI and terminate running processes to free RAM.*
-
-</div> <!-- End of raspberry pi -->
-
-
-<div class="nvidia-jetson">
-
-# Nvidia Jetson TX family
-
-MXNet supports the Ubuntu Arch64 based operating system so you can run MXNet on NVIDIA Jetson Devices.
-
-These instructions will walk through how to build MXNet for the Pascal based [NVIDIA Jetson TX2](http://www.nvidia.com/object/embedded-systems-dev-kits-modules.html) and install the corresponding python language bindings.
-
-For the purposes of this install guide we will assume that CUDA is already installed on your Jetson device.
-
-**Install MXNet**
-
-Installing MXNet is a two-step process:
-
-1. Build the shared library from the MXNet C++ source code.
-2. Install the supported language-specific packages for MXNet.
-
-**Step 1** Build the Shared Library
-
-You need the following additional dependencies:
-
-- Git (to pull code from GitHub)
-
-- libatlas (for linear algebraic operations)
-
-- libopencv (for computer vision operations)
-
-- python pip (to load relevant python packages for our language bindings)
-
-Install these dependencies using the following commands in any directory:
-
-```bash
- sudo apt-get update
- sudo apt-get -y install git build-essential libatlas-base-dev libopencv-dev graphviz python-pip
- sudo pip install pip --upgrade
- sudo pip install setuptools numpy --upgrade
- sudo pip install graphviz jupyter
-```
-
-Clone the MXNet source code repository using the following `git` command in your home directory:
-```bash
- git clone https://github.com/apache/incubator-mxnet.git --recursive
- cd incubator-mxnet
-```
-
-Edit the Makefile to install the MXNet with CUDA bindings to leverage the GPU on the Jetson:
-```bash
- cp make/crosscompile.jetson.mk config.mk
-```
-
-Edit the Mshadow Makefile to ensure MXNet builds with Pascal's hardware level low precision acceleration by editing 3rdparty/mshadow/make/mshadow.mk and adding the following after line 122:
-```bash
-MSHADOW_CFLAGS += -DMSHADOW_USE_PASCAL=1
-```
-
-Now you can build the complete MXNet library with the following command:
-```bash
- make -j $(nproc)
-```
-
-Executing this command creates a file called `libmxnet.so` in the mxnet/lib directory.
-
-**Step 2** Install MXNet Python Bindings
-
-To install Python bindings run the following commands in the MXNet directory:
-
-```bash
- cd python
- pip install --upgrade pip
- pip install -e .
-```
-
-Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
-
-Add the mxnet folder to the path:
-
-```bash
- cd ..
- export MXNET_HOME=$(pwd)
- echo "export PYTHONPATH=$MXNET_HOME/python:$PYTHONPATH" >> ~/.bashrc
- source ~/.bashrc
-```
-
-You are now ready to run MXNet on your NVIDIA Jetson TX2 device.
-
-</div> <!-- End of jetson -->
-</div> <!-- End of devices -->
-
-
-<!-- This # tag restarts the page and allows reuse
- of the div classes for validation sections, etc -->
-
-
-# Validate MXNet Installation
-
-<div class="linux macos">
-<div class="python">
-<div class="cpu">
-
-<div class="pip build-from-source">
-
-Start the python terminal.
-
-```bash
-$ python
-```
-</div>
-
-<div class="docker">
-
-Launch a Docker container with `mxnet/python` image and run example *MXNet* python program on the terminal.
-
-```bash
-$ docker run -it mxnet/python bash # Use sudo if you skip Step 2 in the installation instruction
-
-# Start a python terminal
-root@4919c4f58cac:/# python
-```
-</div>
-
-<div class="virtualenv">
-
-Activate the virtualenv environment created for *MXNet*.
-
-```bash
-$ source ~/mxnet/bin/activate
-```
-
-After activating the environment, you should see the prompt as below.
-
-```bash
-(mxnet)$
-```
-
-Start the python terminal.
-
-```bash
-$ python
-```
-
-</div>
-
-Run a short *MXNet* python program to create a 2X3 matrix of ones, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3.
-
-```python
->>> import mxnet as mx
->>> a = mx.nd.ones((2, 3))
->>> b = a * 2 + 1
->>> b.asnumpy()
-array([[ 3., 3., 3.],
- [ 3., 3., 3.]], dtype=float32)
-```
-</div><!-- linux macos -->
-</div><!-- python -->
-</div><!-- cpu -->
-
-<!-- Validate Windows CPU pip install -->
-
-<div class="windows">
-<div class="python">
-<div class="cpu">
-<div class="pip">
-
-Run a short *MXNet* python program to create a 2X3 matrix of ones, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3.
-
-```python
->>> import mxnet as mx
->>> a = mx.nd.ones((2, 3))
->>> b = a * 2 + 1
->>> b.asnumpy()
-array([[ 3., 3., 3.],
- [ 3., 3., 3.]], dtype=float32)
-```
-
-</div>
-</div>
-</div>
-</div>
-
-<!-- Mac OS GPU installation validation -->
-
-<div class="macos">
-<div class="python">
-<div class="gpu">
-
-<div class="pip virtualenv docker">
-</br>
-
-Will be available soon.
-
-</div>
-
-<div class="build-from-source">
-</br>
-
-From the MXNet root directory run: `python example/image-classification/train_mnist.py --network lenet --gpus 0` to test GPU training.
-
-</div>
-
-</div>
-</div>
-</div>
-
-<!-- Windows GPU installation validation -->
-
-<div class="windows">
-<div class="python">
-<div class="gpu">
-
-<div class="virtualenv docker">
-</br>
-
-Will be available soon.
-
-</div>
-
-<div class="pip build-from-source">
-</br>
-
-From the MXNet root directory run: `python example/image-classification/train_mnist.py --network lenet --gpus 0` to test GPU training.
-
-</div>
-
-</div><!-- windows -->
-</div><!-- python -->
-</div><!-- gpu -->
-
-<!-- Validation for GPU machines -->
-
-<div class="linux">
-<div class="python">
-<div class="gpu">
-
-<div class="pip build-from-source">
-
-Start the python terminal.
-
-```bash
-$ python
-```
-</div>
-
-<div class="docker">
-
-Launch a NVIDIA Docker container with `mxnet/python:gpu` image and run example *MXNet* python program on the terminal.
-
-```bash
-$ nvidia-docker run -it mxnet/python:gpu bash # Use sudo if you skip Step 2 in the installation instruction
-
-# Start a python terminal
-root@4919c4f58cac:/# python
-```
-</div>
-
-<div class="virtualenv">
-
-Activate the virtualenv environment created for *MXNet*.
-
-```bash
-$ source ~/mxnet/bin/activate
-```
-
-After activating the environment, you should see the prompt as below.
-
-```bash
-(mxnet)$
-```
-
-Start the python terminal.
-
-```bash
-$ python
-```
-
-</div>
-
-Run a short *MXNet* python program to create a 2X3 matrix of ones *a* on a *GPU*, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3. We use *mx.gpu()*, to set *MXNet* context to be GPUs.
-
-```python
->>> import mxnet as mx
->>> a = mx.nd.ones((2, 3), mx.gpu())
->>> b = a * 2 + 1
->>> b.asnumpy()
-array([[ 3., 3., 3.],
- [ 3., 3., 3.]], dtype=float32)
-```
-</div><!-- linux -->
-</div><!-- python -->
-</div><!-- gpu -->
-
-
-
-
-
-
-<!-- Linux Clean up -->
-<div class="linux">
-<div class="python">
-<div class="cpu">
-
-<div class="pip build-from-source">
-
-Exit the Python terminal.
-
-```python
->>> exit()
-$
-```
-</div>
-
-<div class="virtualenv">
-
-Exit the Python terminal and Deactivate the virtualenv *MXNet* environment.
-```python
->>> exit()
-(mxnet)$ deactivate
-$
-```
-
-</div>
-
-<div class="docker">
-
-Exit the Python terminal and mxnet/python docker container.
-```python
->>> exit()
-root@4919c4f58cac:/# exit
-```
-
-</div>
-
-</div>
-</div>
-</div>
-
-<!-- MacOS Clean up -->
-<div class="macos">
-<div class="python">
-<div class="cpu">
-
-<div class="pip build-from-source">
-
-Exit the Python terminal.
-
-```python
->>> exit()
-$
-```
-</div>
-
-<div class="virtualenv">
-
-Exit the Python terminal and Deactivate the virtualenv *MXNet* environment.
-```python
->>> exit()
-(mxnet)$ deactivate
-$
-```
-
-</div>
-
-<div class="docker">
-
-Exit the Python terminal and then the docker container.
-```python
->>> exit()
-root@4919c4f58cac:/# exit
-```
-
-</div>
-
-</div>
-</div>
-</div>
-
-<!-- Validation for cloud installation -->
-
-<div class="cloud">
-
-Login to the cloud instance you launched, with pre-installed *MXNet*, following the guide by corresponding cloud provider.
-
-
-Start the python terminal.
-
-```bash
-$ python
-```
-<!-- Example Python code for CPU -->
-
-<div class="cpu">
-
-Run a short *MXNet* python program to create a 2X3 matrix of ones, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3.
-
-```python
->>> import mxnet as mx
->>> a = mx.nd.ones((2, 3))
->>> b = a * 2 + 1
->>> b.asnumpy()
-array([[ 3., 3., 3.],
- [ 3., 3., 3.]], dtype=float32)
- ```
-
-Exit the Python terminal.
-
-```python
->>> exit()
-$
-```
-
-</div>
-
-<!-- Example Python code for CPU -->
-
-<div class="gpu">
-
-Run a short *MXNet* python program to create a 2X3 matrix of ones *a* on a *GPU*, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3. We use *mx.gpu()*, to set *MXNet* context to be GPUs.
-
-```python
->>> import mxnet as mx
->>> a = mx.nd.ones((2, 3), mx.gpu())
->>> b = a * 2 + 1
->>> b.asnumpy()
-array([[ 3., 3., 3.],
- [ 3., 3., 3.]], dtype=float32)
-```
-
-</div>
-
-</div>
-
-<!-- Example R code for CPU -->
-
-<div class="linux macos windows">
-<div class="r">
-<div class="cpu">
-
-Run a short *MXNet* R program to create a 2X3 matrix of ones, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3.
-
-```r
-library(mxnet)
-a <- mx.nd.ones(c(2,3), ctx = mx.cpu())
-b <- a * 2 + 1
-b
-```
-
-You should see the following output:
-
-```r
-[,1] [,2] [,3]
-[1,] 3 3 3
-[2,] 3 3 3
-```
-
-</div>
-</div>
-</div>
-
-<!-- Example R code for GPU -->
-
-<div class="linux macos windows">
-<div class="r">
-<div class="gpu">
-
-Run a short *MXNet* R program to create a 2X3 matrix of ones *a* on a *GPU*, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3. We use *mx.gpu()*, to set *MXNet* context to be GPUs.
-
-```r
-library(mxnet)
-a <- mx.nd.ones(c(2,3), ctx = mx.gpu())
-b <- a * 2 + 1
-b
-```
-
-You should see the following output:
-
-```r
-[,1] [,2] [,3]
-[1,] 3 3 3
-[2,] 3 3 3
-```
-
-</div>
-</div>
-</div>
-
-
-
-<div class="linux">
-<div class="scala">
-
-<div class="cpu gpu">
- Run the <a href="https://github.com/apache/incubator-mxnet/tree/master/scala-package/mxnet-demo">MXNet-Scala demo project</a> to validate your Maven package installation.
-</div>
-
-</div><!-- scala -->
-
-<div class="julia perl cpp">
-<div class="cpu gpu">
-
-Will be available soon.
-
-</div><!-- cpu gpu -->
-</div><!-- julia perl cpp -->
-</div><!-- linux -->
-
-<div class="macos">
-<div class="scala">
-<div class="cpu gpu">
- Run the <a href="https://github.com/apache/incubator-mxnet/tree/master/scala-package/mxnet-demo">MXNet-Scala demo project</a> to validate your Maven package installation.
-</div><!-- cpu gpu-->
-</div><!-- scala -->
-<div class="julia perl cpp">
-<div class="cpu gpu">
-
-Will be available soon.
-
-</div><!-- cpu gpu -->
-</div><!-- julia perl cpp -->
-</div><!-- macos -->
-
-<!-- Windows MXNet Installation validation -->
-<div class="windows">
-<div class="python">
-<div class="cpu">
-
-<div class="build-from-source virtualenv docker">
-<br/>
-Will be available soon.
-</div>
-
-</div>
-</div>
-
-<div class="scala julia perl cpp">
-<div class="cpu gpu">
-
-Will be available soon.
-
-</div>
-</div>
-</div>
-<!-- End Windows Installation validation -->
-
-<br/>
<!-- Download -->
+<hr>
# Source Download
-<a href="download.html">Download</a> your required version of MXNet.
+<a href="download.html">Download</a> your required version of MXNet and <a href="build_from_source.html">build from source</a>.
diff --git a/docs/install/osx_setup.md b/docs/install/osx_setup.md
index b90dfd1e582..53039252888 100644
--- a/docs/install/osx_setup.md
+++ b/docs/install/osx_setup.md
@@ -102,11 +102,22 @@ If building with ```GPU``` support, add the following configuration to config.mk
We have installed MXNet core library. Next, we will install MXNet interface package for the programming language of your choice:
+- [Python](#install-mxnet-for-python)
- [R](#install-the-mxnet-package-for-r)
- [Julia](#install-the-mxnet-package-for-julia)
- [Scala](#install-the-mxnet-package-for-scala)
- [Perl](#install-the-mxnet-package-for-perl)
+## Install MXNet for Python
+To install the MXNet Python binding navigate to the root of the MXNet folder then run the following:
+
+```bash
+$ cd python
+$ pip install -e .
+```
+
+Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
+
## Install the MXNet Package for R
You have 2 options:
1. Building MXNet with the Prebuilt Binary Package
diff --git a/docs/install/ubuntu_setup.md b/docs/install/ubuntu_setup.md
index 13280b58573..432310dd763 100644
--- a/docs/install/ubuntu_setup.md
+++ b/docs/install/ubuntu_setup.md
@@ -115,8 +115,8 @@ You can build MXNet from source, and then you have the option of installing lang
### Build the Shared Library
-#### Quick MXNet Installation
-You can quickly build MXNet with the following script found in the `/docs/install` folder:
+#### Quick MXNet Build
+You can quickly build MXNet from source with the following script found in the `/docs/install` folder:
```bash
cd docs/install
@@ -127,6 +127,8 @@ Or you can go through a manual process described next.
#### Manual MXNet Installation
+It is recommended that you review the general [build from source](build_from_source.html) instructions before continuing.
+
On Ubuntu versions 16.04 or later, you need the following dependencies:
**Step 1:** Install build tools and git.
@@ -135,14 +137,18 @@ On Ubuntu versions 16.04 or later, you need the following dependencies:
sudo apt-get install -y build-essential git
```
-**Step 2:** Install OpenBLAS.
+**Step 2:** Install a Math Library.
+
+Details on the different math libraries are found in the build from source guide's [Math Library Selection](build_from_source.html#math-library-selection) section.
-*MXNet* uses [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) library for accelerated numerical computations on CPU machine. There are several flavors of BLAS libraries - [OpenBLAS](http://www.openblas.net/), [ATLAS](http://math-atlas.sourceforge.net/) and [MKL](https://software.intel.com/en-us/intel-mkl). In this step we install OpenBLAS. You can choose to install ATLAS or MKL.
+For OpenBLAS use:
```bash
sudo apt-get install -y libopenblas-dev
```
+For other libraries, visit the [Math Library Selection](build_from_source.html#math-library-selection) section.
+
**Step 3:** Install OpenCV.
*MXNet* uses [OpenCV](http://opencv.org/) for efficient image loading and augmentation operations.
@@ -153,7 +159,7 @@ On Ubuntu versions 16.04 or later, you need the following dependencies:
**Step 4:** Download MXNet sources and build MXNet core shared library.
-If building on CPU:
+If building on CPU and using OpenBLAS:
```bash
git clone --recursive https://github.com/apache/incubator-mxnet.git
@@ -161,7 +167,7 @@ If building on CPU:
make -j $(nproc) USE_OPENCV=1 USE_BLAS=openblas
```
-If building on GPU (make sure you have installed the [CUDA dependencies first](#cuda-dependencies)):
+If building on GPU and you want OpenCV and OpenBLAS (make sure you have installed the [CUDA dependencies first](#cuda-dependencies)):
```bash
git clone --recursive https://github.com/apache/incubator-mxnet.git
@@ -169,38 +175,119 @@ If building on GPU (make sure you have installed the [CUDA dependencies first](#
make -j $(nproc) USE_OPENCV=1 USE_BLAS=openblas USE_CUDA=1 USE_CUDA_PATH=/usr/local/cuda USE_CUDNN=1
```
-*Note* - USE_OPENCV and USE_BLAS are make file flags to set compilation options to use OpenCV and BLAS library. You can explore and use more compilation options in `make/config.mk`.
+*Note* - USE_OPENCV and USE_BLAS are make file flags to set compilation options to use OpenCV and BLAS library. You can explore and use more compilation options in `make/config.mk` and also review common [usage examples](build_from_source.html#usage-examples).
-Executing these commands creates a library called ```libmxnet.so```.
+Building from source creates a library called ```libmxnet.so``` in the `lib` folder in your MXNet project root.
-Next, you may optionally install ```graphviz``` library that is used for visualizing network graphs you build on MXNet. You may also install [Jupyter Notebook](http://jupyter.readthedocs.io/) which is used for running MXNet tutorials and examples.
+You may also want to add the MXNet shared library to your `LD_LIBRARY_PATH`:
```bash
- sudo apt-get install -y python-pip
- sudo pip install graphviz
- sudo pip install jupyter
+export LD_LIBRARY_PATH=~/incubator-mxnet/lib
```
+
+After building the MXNet library, you may install language bindings.
+
<hr>
## Installing Language Packages for MXNet
After you have installed the MXNet core library. You may install MXNet interface packages for the programming language of your choice:
-- [Scala](#install-the-mxnet-package-for-scala)
-- [R](#install-the-mxnet-package-for-r)
+- [Python](#install-mxnet-for-python)
+- [C++](#install-the-mxnet-package-for-c++)
+- [Clojure](#install-the-mxnet-package-for-clojure)
- [Julia](#install-the-mxnet-package-for-julia)
- [Perl](#install-the-mxnet-package-for-perl)
+- [R](#install-the-mxnet-package-for-r)
+- [Scala](#install-the-mxnet-package-for-scala)
+<hr>
-### Install the MXNet Package for Scala
+### Install MXNet for Python
-To use the MXNet-Scala package, you can acquire the Maven package as a dependency.
+To install the MXNet Python binding navigate to the root of the MXNet folder then run the following:
-Further information is in the [MXNet-Scala Setup Instructions](scala_setup.html).
+```bash
+$ cd python
+$ pip install -e .
+```
-If you use IntelliJ or a similar IDE, you may want to follow the [MXNet-Scala on IntelliJ tutorial](../tutorials/scala/mxnet_scala_on_intellij.html) instead.
+Note that the `-e` flag is optional. It is equivalent to `--editable` and means that if you edit the source files, these changes will be reflected in the package installed.
+
+#### Optional Python Packages
+
+You may optionally install ```graphviz``` library that is used for visualizing network graphs you build on MXNet. You may also install [Jupyter Notebook](http://jupyter.readthedocs.io/) which is used for running MXNet tutorials and examples.
+
+```bash
+sudo pip install graphviz
+sudo pip install jupyter
+```
+<hr>
+
+
+### Install the MXNet Package for C++
+
+Refer to the [C++ Package setup guide](c_plus_plus.html).
+<hr>
+
+
+### Install the MXNet Package for Clojure
+
+Refer to the [Clojure setup guide](https://github.com/apache/incubator-mxnet/tree/master/contrib/clojure-package).
+<hr>
+
+
+### Install the MXNet Package for Julia
+
+The MXNet package for Julia is hosted in a separate repository, MXNet.jl, which is available on [GitHub](https://github.com/dmlc/MXNet.jl). To use Julia binding it with an existing libmxnet installation, set the ```MXNET_HOME``` environment variable by running the following command:
+
+```bash
+ export MXNET_HOME=/<path to>/libmxnet
+```
+
+The path to the existing libmxnet installation should be the root directory of libmxnet. In other words, you should be able to find the ```libmxnet.so``` file at ```$MXNET_HOME/lib```. For example, if the root directory of libmxnet is ```~```, you would run the following command:
+
+```bash
+ export MXNET_HOME=/~/libmxnet
+```
+
+You might want to add this command to your ```~/.bashrc``` file. If you do, you can install the Julia package in the Julia console using the following command:
+
+```julia
+ Pkg.add("MXNet")
+```
+
+For more details about installing and using MXNet with Julia, see the [MXNet Julia documentation](http://dmlc.ml/MXNet.jl/latest/user-guide/install/).
+<hr>
+
+
+### Install the MXNet Package for Perl
+
+Before you build MXNet for Perl from source code, you must complete [building the shared library](#build-the-shared-library). After you build the shared library, run the following command from the MXNet source root directory to build the MXNet Perl package:
+
+```bash
+ sudo apt-get install libmouse-perl pdl cpanminus swig libgraphviz-perl
+ cpanm -q -L "${HOME}/perl5" Function::Parameters Hash::Ordered PDL::CCS
+
+ MXNET_HOME=${PWD}
+ export LD_LIBRARY_PATH=${MXNET_HOME}/lib
+ export PERL5LIB=${HOME}/perl5/lib/perl5
+
+ cd ${MXNET_HOME}/perl-package/AI-MXNetCAPI/
+ perl Makefile.PL INSTALL_BASE=${HOME}/perl5
+ make install
+
+ cd ${MXNET_HOME}/perl-package/AI-NNVMCAPI/
+ perl Makefile.PL INSTALL_BASE=${HOME}/perl5
+ make install
+
+ cd ${MXNET_HOME}/perl-package/AI-MXNet/
+ perl Makefile.PL INSTALL_BASE=${HOME}/perl5
+ make install
+```
<hr>
+
### Install the MXNet Package for R
Building *MXNet* from source is a 2 step process.
@@ -291,69 +378,19 @@ You should see the following output:
[2,] 3 3 3
> quit()
```
-
<hr>
-### Install the MXNet Package for Julia
-
-The MXNet package for Julia is hosted in a separate repository, MXNet.jl, which is available on [GitHub](https://github.com/dmlc/MXNet.jl). To use Julia binding it with an existing libmxnet installation, set the ```MXNET_HOME``` environment variable by running the following command:
-
-```bash
- export MXNET_HOME=/<path to>/libmxnet
-```
-
-The path to the existing libmxnet installation should be the root directory of libmxnet. In other words, you should be able to find the ```libmxnet.so``` file at ```$MXNET_HOME/lib```. For example, if the root directory of libmxnet is ```~```, you would run the following command:
-
-```bash
- export MXNET_HOME=/~/libmxnet
-```
-
-You might want to add this command to your ```~/.bashrc``` file. If you do, you can install the Julia package in the Julia console using the following command:
-
-```julia
- Pkg.add("MXNet")
-```
-
-For more details about installing and using MXNet with Julia, see the [MXNet Julia documentation](http://dmlc.ml/MXNet.jl/latest/user-guide/install/).
-<hr>
-
-
-## Install the MXNet Package for Scala
+### Install the MXNet Package for Scala
To use the MXNet-Scala package, you can acquire the Maven package as a dependency.
-Further information is in the [MXNet-Scala Setup Instructions](./scala_setup.md).
-
-If you use IntelliJ or a similar IDE, you may want to follow the [MXNet-Scala on IntelliJ tutorial](../tutorials/scala/mxnet_scala_on_intellij.md) instead.
-
-
-### Install the MXNet Package for Perl
-
-Before you build MXNet for Perl from source code, you must complete [building the shared library](#build-the-shared-library). After you build the shared library, run the following command from the MXNet source root directory to build the MXNet Perl package:
-
-```bash
- sudo apt-get install libmouse-perl pdl cpanminus swig libgraphviz-perl
- cpanm -q -L "${HOME}/perl5" Function::Parameters Hash::Ordered PDL::CCS
-
- MXNET_HOME=${PWD}
- export LD_LIBRARY_PATH=${MXNET_HOME}/lib
- export PERL5LIB=${HOME}/perl5/lib/perl5
-
- cd ${MXNET_HOME}/perl-package/AI-MXNetCAPI/
- perl Makefile.PL INSTALL_BASE=${HOME}/perl5
- make install
-
- cd ${MXNET_HOME}/perl-package/AI-NNVMCAPI/
- perl Makefile.PL INSTALL_BASE=${HOME}/perl5
- make install
+Further information is in the [MXNet-Scala Setup Instructions](scala_setup.html).
- cd ${MXNET_HOME}/perl-package/AI-MXNet/
- perl Makefile.PL INSTALL_BASE=${HOME}/perl5
- make install
-```
+If you use IntelliJ or a similar IDE, you may want to follow the [MXNet-Scala on IntelliJ tutorial](../tutorials/scala/mxnet_scala_on_intellij.html) instead.
<hr>
+
## Contributions
You are more than welcome to contribute easy installation scripts for other operating systems and programming languages. See the [community contributions page](../community/contribute.html) for further information.
diff --git a/docs/install/validate_mxnet.md b/docs/install/validate_mxnet.md
new file mode 100644
index 00000000000..a4cf5446f60
--- /dev/null
+++ b/docs/install/validate_mxnet.md
@@ -0,0 +1,185 @@
+# Validate Your MXNet Installation
+
+- [Python](#python)
+- [Python with GPU](#python-with-gpu)
+- [Verify GPU training](#verify-gpu-training)
+- [Virtualenv](#virtualenv)
+- [Docker with CPU](#docker-with-cpu)
+- [Docker with GPU](#docker-with-gpu)
+- [Cloud](#cloud)
+- [C++](#alternative-language-bindings)
+- [Clojure](#clojure)
+- [Julia](#julia)
+- [Perl](#perl)
+- [R](#r)
+- [Scala](#scala)
+
+
+## Python
+
+Start the python terminal.
+
+```bash
+$ python
+```
+
+Run a short *MXNet* python program to create a 2X3 matrix of ones, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3.
+
+```python
+>>> import mxnet as mx
+>>> a = mx.nd.ones((2, 3))
+>>> b = a * 2 + 1
+>>> b.asnumpy()
+array([[ 3., 3., 3.],
+ [ 3., 3., 3.]], dtype=float32)
+```
+
+
+## Python with GPU
+
+This is similar to the previous example, but this time we use *mx.gpu()*, to set *MXNet* context to be GPUs.
+
+```python
+>>> import mxnet as mx
+>>> a = mx.nd.ones((2, 3), mx.gpu())
+>>> b = a * 2 + 1
+>>> b.asnumpy()
+array([[ 3., 3., 3.],
+ [ 3., 3., 3.]], dtype=float32)
+```
+
+
+## Verify GPU Training
+
+From the MXNet root directory run: `python example/image-classification/train_mnist.py --network lenet --gpus 0` to test GPU training.
+
+
+## Virtualenv
+
+Activate the virtualenv environment created for *MXNet*.
+
+```bash
+$ source ~/mxnet/bin/activate
+```
+
+After activating the environment, you should see the prompt as below.
+
+```bash
+(mxnet)$
+```
+
+Start the python terminal.
+
+```bash
+$ python
+```
+
+Run the previous Python example.
+
+
+## Docker with CPU
+
+Launch a Docker container with `mxnet/python` image and run example *MXNet* python program on the terminal.
+
+```bash
+$ docker run -it mxnet/python bash # Use sudo if you skip Step 2 in the installation instruction
+
+# Start a python terminal
+root@4919c4f58cac:/# python
+```
+
+Run the previous Python example.
+
+
+## Docker with GPU
+
+Launch a NVIDIA Docker container with `mxnet/python:gpu` image and run example *MXNet* python program on the terminal.
+
+```bash
+$ nvidia-docker run -it mxnet/python:gpu bash # Use sudo if you skip Step 2 in the installation instruction
+
+# Start a python terminal
+root@4919c4f58cac:/# python
+```
+
+Run the previous Python example and run the previous GPU examples.
+
+
+## Cloud
+
+Login to the cloud instance you launched, with pre-installed *MXNet*, following the guide by corresponding cloud provider.
+
+Start the python terminal.
+
+```bash
+$ python
+```
+
+Run the previous Python example, and for GPU instances run the previous GPU example.
+
+
+## Alternative Language Bindings
+
+### C++
+
+Please contribute an example!
+
+
+### Clojure
+
+Please contribute an example!
+
+
+### Julia
+
+Please contribute an example!
+
+
+### Perl
+
+Please contribute an example!
+
+
+### R
+
+Run a short *MXNet* R program to create a 2X3 matrix of ones, multiply each element in the matrix by 2 followed by adding 1. We expect the output to be a 2X3 matrix with all elements being 3.
+
+```r
+library(mxnet)
+a <- mx.nd.ones(c(2,3), ctx = mx.cpu())
+b <- a * 2 + 1
+b
+```
+
+You should see the following output:
+
+```r
+[,1] [,2] [,3]
+[1,] 3 3 3
+[2,] 3 3 3
+```
+
+
+#### R with GPU
+
+This is similar to the previous example, but this time we use *mx.gpu()*, to set *MXNet* context to be GPUs.
+
+```r
+library(mxnet)
+a <- mx.nd.ones(c(2,3), ctx = mx.gpu())
+b <- a * 2 + 1
+b
+```
+
+You should see the following output:
+
+```r
+[,1] [,2] [,3]
+[1,] 3 3 3
+[2,] 3 3 3
+```
+
+
+### Scala
+
+Run the <a href="https://github.com/apache/incubator-mxnet/tree/master/scala-package/mxnet-demo">MXNet-Scala demo project</a> to validate your Maven package installation.
diff --git a/docs/install/windows_setup.md b/docs/install/windows_setup.md
index 40ddeb8182d..99ce7f63e85 100755
--- a/docs/install/windows_setup.md
+++ b/docs/install/windows_setup.md
@@ -91,7 +91,7 @@ Done! We have installed MXNet with Python interface. Run below commands to verif
```
We actually did a small tensor computation using MXNet! You are all set with MXNet on your Windows machine.
-## Install MXNet Package for R
+## Install the MXNet Package for R
MXNet for R is available for both CPUs and GPUs.
### Installing MXNet on a Computer with a CPU Processor
@@ -151,8 +151,8 @@ These dlls can be found in `prebuildbase_win10_x64_vc14/3rdparty`, `mxnet_x64_vc
├── dmlc
├── mxnet
├── mshadow
- └── nnvm
-
+ └── nnvm
+
```
6. Make sure that R executable is added to your ```PATH``` in the environment variables. Running the ```where R``` command at the command prompt should return the location.
7. Also make sure that Rtools is installed and the executable is added to your ```PATH``` in the environment variables.
@@ -200,7 +200,7 @@ To install MXNet on a computer with a GPU processor, choose from two options:
* Build the library from source code
However, a few dependencies remain for both options. You will need the following:
-* Install [Nvidia-drivers](http://www.nvidia.com/Download/index.aspx?lang=en-us) if not installed. Latest driver based on your system configuration is recommended.
+* Install [Nvidia-drivers](http://www.nvidia.com/Download/index.aspx?lang=en-us) if not installed. Latest driver based on your system configuration is recommended.
* Install [Microsoft Visual Studio](https://visualstudio.microsoft.com/downloads/) (VS2015 or VS2017 is required by CUDA)
@@ -224,7 +224,7 @@ For GPU package:
```
Change cu92 to cu80, cu90 or cu91 based on your CUDA toolkit version. Currently, MXNet supports these versions of CUDA.
#### Building MXNet from Source Code(GPU)
-After you have installed above software, continue with the following steps to build MXNet-R:
+After you have installed above software, continue with the following steps to build MXNet-R:
1. Clone the MXNet github repo.
```sh
@@ -261,8 +261,8 @@ These dlls can be found in `prebuildbase_win10_x64_vc14/3rdparty`, `mxnet_x64_vc
├── dmlc
├── mxnet
├── mshadow
- └── nnvm
-
+ └── nnvm
+
```
6. Make sure that R executable is added to your ```PATH``` in the environment variables. Running the ```where R``` command at the command prompt should return the location.
7. Also make sure that Rtools is installed and the executable is added to your ```PATH``` in the environment variables.
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services