From 6f6e90a8203f9ec4c728206ab2d0a5789ae497ae Mon Sep 17 00:00:00 2001
From: JiabinYang <marsyang199376@gmail.com>
Date: Thu, 6 Sep 2018 10:01:30 +0000
Subject: [PATCH] renew install_doc for release_0.15.0

---
 doc/fluid/new_docs/beginners_guide/index.rst  |    2 +-
 .../beginners_guide/install/install_doc.md    | 1503 +++++++++++++++++
 .../beginners_guide/install/install_doc.rst   |  543 ------
 .../beginners_guide/install/paddleci.png      |  Bin 40242 -> 0 bytes
 4 files changed, 1504 insertions(+), 544 deletions(-)
 create mode 100644 doc/fluid/new_docs/beginners_guide/install/install_doc.md
 delete mode 100644 doc/fluid/new_docs/beginners_guide/install/install_doc.rst
 delete mode 100644 doc/fluid/new_docs/beginners_guide/install/paddleci.png

diff --git a/doc/fluid/new_docs/beginners_guide/index.rst b/doc/fluid/new_docs/beginners_guide/index.rst
index e18933dcc0..b15106692b 100644
--- a/doc/fluid/new_docs/beginners_guide/index.rst
+++ b/doc/fluid/new_docs/beginners_guide/index.rst
@@ -9,7 +9,7 @@
 ..  toctree::
     :maxdepth: 2
     
-    install/install_doc.rst
+    install/install_doc.md
     quick_start/index.rst
     basics/index.rst
     basics/learning_materials.md
diff --git a/doc/fluid/new_docs/beginners_guide/install/install_doc.md b/doc/fluid/new_docs/beginners_guide/install/install_doc.md
new file mode 100644
index 0000000000..ed670ec55f
--- /dev/null
+++ b/doc/fluid/new_docs/beginners_guide/install/install_doc.md
@@ -0,0 +1,1503 @@
+# **安装说明**
+本说明将指导您在*64位台式机或笔记本电脑*上编译和安装PaddlePaddle，目前PaddlePaddle支持以下环境：
+
+* *Ubuntu 14.04 /16.04 /18.04*
+* *CentOS 7 / 6*
+* *MacOS 10.12 / 10.13*
+* *Windows7 / 8/ 10(专业版/企业版)*
+
+请确保您的环境满足以上条件       
+如在安装或编译过程中遇到问题请参见[FAQ](#FAQ)          
+
+
+## **安装PaddlePaddle**
+
+* Ubuntu下安装PaddlePaddle
+* CentOS下安装PaddlePaddle
+* MacOS下安装PaddlePaddle
+* Windows下安装PaddlePaddle
+
+***
+### **Ubuntu下安装PaddlePaddle**
+
+本说明将介绍如何在*64位台式机或笔记本电脑*以及Ubuntu系统下安装PaddlePaddle，我们支持的Ubuntu系统需满足以下要求：
+
+请注意：在其他系统上的尝试可能会导致安装失败。
+
+* *Ubuntu 14.04 /16.04 /18.04*
+
+#### 确定要安装的PaddlePaddle版本
+
+* 仅支持CPU的PaddlePaddle。如果您的计算机没有 NVIDIA® GPU，则只能安装此版本。如果您的计算机有GPU，
+也推荐您先安装CPU版本的PaddlePaddle，来检测您本地的环境是否适合。
+
+* 支持GPU的PaddlePaddle。为了使PaddlePaddle程序运行更加迅速，我们通过GPU对PaddlePaddle程序进行加速，但安装GPU版本的PaddlePaddle需要先拥有满足以下条件的NVIDIA® GPU（具体安装流程和配置请务必参见NVIDIA官方文档：[For CUDA](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)，[For cuDNN](https://docs.nvidia.com/deeplearning/sdk/cudnn-install/)）
+	* *CUDA 工具包9.0配合cuDNN v7*
+	* *CUDA 工具包8.0配合cuDNN v7*
+	* *GPU运算能力超过1.0的硬件设备*
+
+
+
+#### 选择如何安装PaddlePaddle
+在Ubuntu的系统下我们提供4种安装方式：
+
+* Docker安装
+* pip安装
+* 源码编译安装
+* Docker源码编译安装
+
+
+我们更加推荐**使用Docker进行安装**，因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。        
+
+
+**使用pip安装**，我们为您提供pip安装方法，但它更依赖您的本机环境，可能会出现和您本机环境相关的一些问题。         
+
+
+
+从[**源码编译安装**](#ubt_source)以及[**使用Docker进行源码编译安装**](#ubt_docker)，这是一种通过将PaddlePaddle源代码编译成为二进制文件，然后在安装这个二进制文件的过程，相比使用我们为您编译过的已经通过测试的二进制文件形式的PaddlePaddle，手动编译更为复杂，我们将在说明的最后详细为您解答。
+<br/><br/>
+##### ***使用Docker进行安装***
+
+<!-- TODO: uncomment it when the offical website can split it to different pages我们更加推荐**使用Docker进行安装**，因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。-->
+
+为了更好的使用Docker并避免发生问题，我们推荐使用**最高版本的Docker**，关于**安装和使用Docker**的细节请参阅Docker[官方文档](https://docs.docker.com/install/)。
+
+
+
+> 请注意，要安装和使用支持 GPU 的PaddlePaddle版本，您必须先安装[nvidia-docker](https://github.com/NVIDIA/nvidia-docker)
+
+
+
+如果已经**正确安装Docker**，即可以开始**使用Docker安装PaddlePaddle**
+
+1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像：
+
+
+	* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：
+
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:0.15.0`
+		
+
+	* 对于需要**GPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For GPU*的镜像：
+
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:0.15.0-gpu-cuda9.0-cudnn7`
+		
+
+	* 您也可以通过以下指令拉取任意的我们提供的Docker镜像：
+
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]`
+		> （请把[tag]替换为[镜像表](#dockers)中的内容）
+		
+2. 使用以下指令用已经拉取的镜像构建并进入Docker容器：
+
+	`docker run --name [Name of container] -it -v $PWD:/paddle <imagename> /bin/bash`
+
+	> 上述命令中，--name [Name of container] 设定Docker的名称；-it 参数说明容器已和本机交互式运行； -v $PWD:/paddle 指定将当前路径（Linux中PWD变量会展开为当前路径的绝对路径）挂载到容器内部的 /paddle 目录； `<imagename>` 指定需要使用的image名称，如果您需要使用我们的镜像请使用`hub.baidubce.com/paddlepaddle/paddle:[tag]` 注：tag的意义同第二步；/bin/bash是在Docker中要执行的命令。
+
+3. （可选：当您需要第二次进入Docker容器中）使用如下命令使用PaddlePaddle：
+
+	`docker start [Name of container]`
+	> 启动之前创建的容器。
+
+	`docker attach [Name of container]`
+	> 进入启动的容器。
+	
+至此您已经成功使用Docker安装PaddlePaddle，您只需要进入Docker容器后运行PaddlePaddle即可，更多Docker使用请参见[Docker官方文档](https://docs.docker.com)。
+
+> 注：PaddlePaddle Docker镜像为了减小体积，默认没有安装`vim`，您可以在容器中执行 `apt-get install -y vim` 安装后，在容器中编辑代码。
+
+
+<br/><br/>
+##### ***使用pip安装PaddlePaddle***
+
+您可以直接粘贴以下命令到命令行来安装PaddlePaddle(适用于ubuntu16.04及以上安装CPU-ONLY的版本)，如果出现问题，您可以参照后面的解释对命令作出适应您系统的更改：
+		
+	apt update && apt install -y python-dev python-pip && pip install paddlepaddle        
+	
+	
+首先，我们使用以下指令来**检测本机的环境**是否适合安装PaddlePaddle：
+
+`uname -m && cat /etc/*release`
+> 上面的命令将会显示本机的操作系统和位数信息，请确保您的计算机和本教程的要求一致。
+
+
+其次，您的电脑需要满足以下要求：
+
+*	Python2.7.x (dev)
+*	Pip >= 9.0.1     
+	
+	> 您的Ubuntu上可能已经安装pip请使用pip -V来确认我们建议使用pip 9.0.1或更高版本来安装
+
+	更新apt的源：   `apt update`
+
+	使用以下命令安装或升级Python和pip到需要的版本： `sudo apt install python-dev python-pip`
+	> 即使您的环境中已经有Python2.7也需要安装Python dev。
+
+现在，让我们来安装PaddlePaddle：
+
+1. 使用pip install来安装PaddlePaddle
+
+	* 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle`
+	
+
+	* 对于需要**GPU版本PaddlePaddle**的用户：`pip install paddlepaddle-gpu`
+	> 1. 为防止出现nccl.h找不到的问题请首先按照以下命令安装nccl2（这里提供的是ubuntu 16.04，CUDA8，cuDNN v7下nccl2的安装指令），更多版本的安装信息请参考NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download):      
+		a. `wget http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb`             
+		b. `sudo apt-get install libnccl2=2.2.13-1+cuda8.0 libnccl-dev=2.2.13-1+cuda8.0`
+	> 2. 如果您不规定pypi包版本号，我们默认为您提供支持Cuda 8/cuDNN v7的PaddlePaddle版本。
+
+
+	对于出现`Cannot uninstall 'six'.`问题的用户，可是由于您的系统中已有的Python安装问题造成的，请使用`pip install paddlepaddle --ignore-installed six`（CPU）或`pip 	install paddlepaddle --ignore-installed six`（GPU）解决。      
+	
+	* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]`
+	> `版本号`参见[安装包列表](#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[多版本whl包列表](#ciwhls)或者我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。     
+	
+	
+	
+
+现在您已经完成使用`pip install` 来安装的PaddlePaddle的过程。
+
+<br/><br/>
+##### ***验证安装***
+安装完成后您可以使用：`python` 进入python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
+
+<br/><br/>
+##### ***如何卸载PaddlePaddle***
+请使用以下命令卸载PaddlePaddle：
+
+* ***CPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle`
+
+* ***GPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle-gpu`
+
+<br/><br/>
+### **CentOS下安装PaddlePaddle**
+
+本说明将介绍如何在*64位台式机或笔记本电脑*以及CentOS系统下安装PaddlePaddle，我们支持的CentOS系统需满足以下要求：      
+
+
+请注意：在其他系统上的尝试可能会导致安装失败。
+
+* *CentOS 6 / 7*
+
+#### 确定要安装的PaddlePaddle版本
+* 仅支持CPU的PaddlePaddle。如果您的计算机没有 NVIDIA® GPU，则只能安装此版本。如果您的计算机有GPU，
+推荐您先安装CPU版本的PaddlePaddle，来检测您本地的环境是否适合。
+
+* 支持GPU的PaddlePaddle，为了使PaddlePaddle程序运行的更加迅速，我们通过GPU对PaddlePaddle程序进行加速，但安装GPU版本的PaddlePaddle需要先拥有满足以下条件的NVIDIA® GPU（具体安装流程和配置请务必参见NVIDIA官方文档：[For CUDA](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)，[For cuDNN](https://docs.nvidia.com/deeplearning/sdk/cudnn-install/)）
+	* *CUDA 工具包9.0配合cuDNN v7*
+	* *CUDA 工具包8.0配合cuDNN v7*
+	* *GPU运算能力超过1.0的硬件设备*
+
+
+
+#### 选择如何安装PaddlePaddle
+在CentOS的系统下我们提供4种安装方式：
+
+* Docker安装（不支持GPU版本）
+* pip安装
+* 源码编译安装（不支持CentOS 6的所有版本以及CentOS 7的GPU版本）
+* Docker源码编译安装（不支持GPU版本）
+
+
+我们更加推荐**使用Docker进行安装**，因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。        
+
+
+
+**使用pip安装**，我们为您提供pip安装方法，但它更依赖您的本机环境，可能会出现和您本机环境相关的一些问题。
+
+从[**源码编译安装**](#ct_source)以及[**使用Docker进行源码编译安装**](#ct_docker)，这是一种通过将PaddlePaddle源代码编译成为二进制文件，然后在安装这个二进制文件的过程，相比使用我们为您编译过的已经通过测试的二进制文件形式的PaddlePaddle，手动编译更为复杂，我们将在说明的最后详细为您解答。
+<br/><br/>
+##### ***使用Docker进行安装***
+
+<!-- 我们更加推荐**使用Docker进行安装**，因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。-->
+
+为了更好的使用Docker并避免发生问题，我们推荐使用**最高版本的Docker**，关于**安装和使用Docker**的细节请参阅Docker[官方文档](https://docs.docker.com/install/)
+
+
+> 请注意，要安装和使用支持 GPU 的PaddlePaddle版本，您必须先安装[nvidia-docker](https://github.com/NVIDIA/nvidia-docker)
+
+
+
+当您已经**正确安装Docker**后你就可以开始**使用Docker安装PaddlePaddle**
+
+1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像：
+
+
+	* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：
+
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:0.15.0`       
+		
+		
+
+
+	* 您也可以通过以下指令拉取任意的我们提供的Docker镜像：
+
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]`
+		> （请把[tag]替换为[镜像表](#dockers)中的内容）    
+		
+		
+2. 使用以下指令用已经拉取的镜像构建并进入Docker容器：
+
+	`docker run --name [Name of container] -it -v $PWD:/paddle <imagename> /bin/bash`
+	
+	> 上述命令中，--name [Name of container] 设定Docker的名称；-it 参数说明容器已和本机交互式运行； -v $PWD:/paddle 指定将当前路径（Linux中PWD变量会展开为当前路径的[绝对路径](https://baike.baidu.com/item/绝对路径/481185)）挂载到容器内部的 /paddle 目录； `<imagename>` 指定需要使用的image名称，如果您需要使用我们的镜像请使用`hub.baidubce.com/paddlepaddle/paddle:[tag]` 注：tag的意义同第二步，/bin/bash是在Docker中要执行的命令。  
+
+3. （可选：当您需要第二次进入Docker容器中）使用如下命令使用PaddlePaddle：
+
+	`docker start [Name of container]`
+	> 启动之前创建的容器。
+
+	`docker attach [Name of container]`
+	> 进入启动的容器。
+	
+至此您已经成功使用Docker安装PaddlePaddle，您只需要进入Docker容器后运行PaddlePaddle即可，更多Docker使用请参见[Docker官方文档](https://docs.docker.com)。
+> 注：PaddlePaddle Docker镜像为了减小体积，默认没有安装`vim`，您可以在容器中执行 `apt-get install -y vim` 安装后，在容器中编辑代码。
+
+
+<br/><br/>
+##### ***使用pip安装PaddlePaddle***
+
+您可以直接粘贴以下命令到命令行来安装PaddlePaddle(适用于CentOS7安装CPU-ONLY的版本)，如果出现问题，您可以参照后面的解释对命令作出适应您系统的更改：
+		
+	yum update && yum install -y epel-release && yum install -y python-devel python-pip && pip install paddlepaddle && export LD_LIBRARY_PATH=/usr/lib:$LD_LIBRARY_PATH
+
+首先，我们使用以下指令来**检测本机的环境**是否适合安装PaddlePaddle：
+
+`uname -m && cat /etc/*release`
+> 上面的命令将会显示本机的操作系统和位数信息，请确保您的计算机和本教程的要求一致。
+
+
+其次，您的计算机需要满足以下要求：
+
+*	Python2.7.x (devel)   
+	
+	> CentOS6需要编译Python2.7成[共享库](#FAQ)。         
+
+
+*	Pip >= 9.0.1     
+	
+	> 您的CentOS上可能已经安装pip请使用pip -V来确认我们建议使用pip 9.0.1或更高版本来安装。
+
+	更新yum的源：   `yum update` 并安装拓展源以安装pip：   `yum install -y epel-release`
+
+	使用以下命令安装或升级Python和pip到需要的版本： `sudo yum install python-devel python-pip`
+	> 即使您的环境中已经有`Python2.7`也需要安装`python devel`。
+
+下面将说明如何安装PaddlePaddle：
+
+1. 使用pip install来安装PaddlePaddle：
+	
+	* 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle`
+
+
+	* 对于需要**GPU版本PaddlePaddle**的用户: `pip install paddlepaddle-gpu`
+	> 1. 为防止出现nccl.h找不到的问题请首先按照NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download)的指示正确安装nccl2
+	> 2. 如果您不规定pypi包版本号，我们默认为您提供支持Cuda 8/cuDNN v7的PaddlePaddle版本。 
+
+	对于出现`Cannot uninstall 'six'.`问题的用户，可是由于您的系统中已有的Python安装问题造	成的，请使用`pip install paddlepaddle --ignore-installed six`（CPU）或`pip 	install paddlepaddle-gpu --ignore-installed six`（GPU）解决。
+	
+	* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]`
+	> `版本号`参见[安装包列表](#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。            
+	
+	    
+	    
+
+现在您已经完成通过`pip install` 来安装的PaddlePaddle的过程。
+
+
+<br/><br/>
+##### ***验证安装***
+安装完成后您可以使用：`python` 进入Python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
+
+<br/><br/>
+##### ***如何卸载PaddlePaddle***
+请使用以下命令卸载PaddlePaddle：
+
+* ***CPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle`
+
+* ***GPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle-gpu`
+
+
+
+
+<br/><br/>
+### **MacOS下安装PaddlePaddle**
+
+本说明将介绍如何在*64位台式机或笔记本电脑*以及MacOS系统下安装PaddlePaddle，我们支持的MacOS系统需满足以下要求。
+
+请注意：在其他系统上的尝试可能会导致安装失败。
+
+* *MacOS 10.12/10.13*
+
+#### 确定要安装的PaddlePaddle版本
+
+* 仅支持CPU的PaddlePaddle。
+
+
+
+#### 选择如何安装PaddlePaddle
+在MacOS的系统下我们提供3种安装方式：
+
+* Docker安装（不支持GPU版本）
+* Docker源码编译安装（不支持GPU版本）
+
+
+我们更加推荐**使用Docker进行安装**，因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。        
+
+
+
+
+
+<br/><br/>
+##### ***使用Docker进行安装***
+
+<!-- 我们更加推荐**使用Docker进行安装**，因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。-->
+
+为了更好的使用Docker并避免发生问题，我们推荐使用**最高版本的Docker**，关于**安装和使用Docker**的细节请参阅Docker[官方文档](https://docs.docker.com/install/)。
+> 请注意，在MacOS系统下登陆docker需要使用您的dockerID进行登录，否则将出现`Authenticate Failed`错误。
+
+如果已经**正确安装Docker**，即可以开始**使用Docker安装PaddlePaddle**
+
+1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像：
+
+
+	* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：
+
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:0.15.0`
+		
+
+	* 您也可以通过以下指令拉取任意的我们提供的Docker镜像：
+
+		`docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]`
+		> （请把[tag]替换为[镜像表](#dockers)中的内容）
+		
+2. 使用以下指令用已经拉取的镜像构建并进入Docker容器：
+
+	`docker run --name [Name of container] -it -v $PWD:/paddle <imagename> /bin/bash`
+
+	> 上述命令中，--name [Name of container] 设定Docker的名称；-it 参数说明容器已和本机交互式运行； -v $PWD:/paddle 指定将当前路径（Linux中PWD变量会展开为当前路径的[绝对路径](https://baike.baidu.com/item/绝对路径/481185)）挂载到容器内部的 /paddle 目录； `<imagename>` 指定需要使用的image名称，如果您需要使用我们的镜像请使用`hub.baidubce.com/paddlepaddle/paddle:[tag]` 注：tag的意义同第二步；/bin/bash是在Docker中要执行的命令。
+
+3. （可选：当您需要第二次进入Docker容器中）使用如下命令使用PaddlePaddle：
+
+	`docker start [Name of container]`
+	> 启动之前创建的容器。
+
+	`docker attach [Name of container]`
+	> 进入启动的容器。     
+	
+	
+至此您已经成功使用Docker安装PaddlePaddle，您只需要进入Docker容器后运行PaddlePaddle即可，更多Docker使用请参见[Docker官方文档](https://docs.docker.com)。
+
+> 注：PaddlePaddle Docker镜像为了减小体积，默认没有安装`vim`，您可以在容器中执行 `apt-get install -y vim` 安装后，在容器中编辑代码。
+<!--TODO: When we support pip install mode on MacOS, we can write on this part -->
+
+
+
+<br/><br/>
+##### ***验证安装***
+安装完成后您可以使用：`python` 进入python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
+
+<br/><br/>
+##### ***如何卸载PaddlePaddle***
+请使用以下命令卸载PaddlePaddle：
+
+* ***CPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle`     
+
+
+
+
+<br/><br/>
+### **Windows下安装PaddlePaddle**
+
+本说明将介绍如何在*64位台式机或笔记本电脑*以及Windows系统下安装PaddlePaddle，我们支持的Windows系统需满足以下要求。
+
+请注意：在其他系统上的尝试可能会导致安装失败。
+
+* *Windows 7/8 and Windows 10 专业版/企业版*
+
+#### 确定要安装的PaddlePaddle版本
+
+* Windows下我们目前仅提供支持CPU的PaddlePaddle。
+
+
+#### 选择如何安装PaddlePaddle
+在Windows系统下请使用我们为您提供的[一键安装包](http://paddle-windows.bj.bcebos.com/PaddlePaddle-windows.zip)进行安装
+	
+> 我们提供的一键安装包将基于Docker为您进行便捷的安装流程
+
+
+我们之所以使用**基于Docker的安装方式**，是因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。        
+
+
+
+<!--从**源码编译安装**，在Windows下我们不支持**直接源码编译安装**，使用docker进行源码编译的过程将在文档的最后为您展示。-->
+
+
+
+
+<br/><br/>
+##### ***验证安装***
+安装完成后您可以使用：`python` 进入python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
+
+<br/><br/>
+##### ***如何卸载PaddlePaddle***
+请使用以下命令卸载PaddlePaddle：
+
+* ***CPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle`   
+
+
+
+
+
+
+<br/><br/>
+## **从源码编译PaddlePaddle**
+我们也为您提供了从源码编译的方式，但不推荐您使用这种方式，这是因为您的本机环境多种多样，在编译源码时易出现复杂的本说明中覆盖以外问题而造成安装失败。
+      
+***       
+### **Ubuntu下从源码编译PaddlePaddle**
+
+本说明将介绍如何在*64位台式机或笔记本电脑*以及Ubuntu系统下编译PaddlePaddle，我们支持的Ubuntu系统需满足以下要求：
+
+* Ubuntu 14.04/16.04/18.04（这涉及到相关工具是否能被正常安装）
+
+#### 确定要编译的PaddlePaddle版本
+* **仅支持CPU的PaddlePaddle**，如果您的系统没有 NVIDIA® GPU，则必须安装此版本。而此版本较GPU版本更加容易安
+因此即使您的计算机上拥有GPU我们也推荐您先安装CPU版本的PaddlePaddle来检测您本地的环境是否适合。
+
+* **支持GPU的PaddlePaddle**，为了使得PaddlePaddle程序运行的更加迅速，我们通常使用GPU对PaddlePaddle程序进行加速，但安装GPU版本的PaddlePaddle需要先拥有满足以下条件的NVIDIA® GPU（具体安装流程和配置请务必参见NVIDIA官方文档：[For CUDA](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)，[For cuDNN](https://docs.nvidia.com/deeplearning/sdk/cudnn-install/)）
+	* *CUDA 工具包9.0配合cuDNN v7*
+	* *CUDA 工具包8.0配合cuDNN v7*
+	* *GPU运算能力超过1.0的硬件设备*
+
+#### 选择如何编译PaddlePaddle
+在Ubuntu的系统下我们提供2种编译方式：
+
+* Docker源码编译
+* 直接本机源码编译
+
+我们更加推荐**使用Docker进行编译**，因为我们在把工具和配置都安装在一个 Docker image 里。这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。有人用虚拟机来类比 Docker。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。        
+
+
+
+我们也提供了可以从**本机直接源码编译**的方法，但是由于在本机上的情况更加复杂，我们只对特定系统提供了支持。        
+
+<a name="ubt_docker"></a>                         
+
+<br/><br/>
+##### ***使用Docker进行编译***
+为了更好的使用Docker并避免发生问题，我们推荐使用**最高版本的Docker**，关于**安装和使用Docker**的细节请参阅Docker[官方文档](https://docs.docker.com/install/)
+
+
+> 请注意，要安装和使用支持 GPU 的PaddlePaddle版本，您必须先安装[nvidia-docker](https://github.com/NVIDIA/nvidia-docker)
+
+
+
+当您已经**正确安装Docker**后你就可以开始**使用Docker编译PaddlePaddle**：
+
+1. 请首先选择您希望储存PaddlePaddle的路径，然后在该路径下使用以下命令将PaddlePaddle的源码从github克隆到本地当前目录下名为Paddle的文件夹中：
+
+	`git clone https://github.com/PaddlePaddle/Paddle.git`
+
+2. 进入Paddle目录下： `cd Paddle`
+
+3. 利用我们提供的镜像（使用该命令您可以不必提前下载镜像）：
+
+	`docker run --name paddle-test -v $PWD:/paddle --network=host -it hub.baidubce.com/paddlepaddle/paddle:latest-dev /bin/bash`
+	> --name paddle-test为您创建的Docker容器命名为paddle-test，-v $PWD:/paddle 将当前目录挂载到Docker容器中的/paddle目录下（Linux中PWD变量会展开为当前路径的[绝对路径](https://baike.baidu.com/item/绝对路径/481185)），-it 与宿主机保持交互状态，`hub.baidubce.com/paddlepaddle/paddle:latest-dev` 使用名为`hub.baidubce.com/paddlepaddle/paddle:latest-dev`的镜像创建Docker容器，/bin/bash 进入容器后启动/bin/bash命令。
+
+4. 进入Docker后进入paddle目录下：`cd paddle`
+
+5. 切换到较稳定release分支下进行编译：
+
+	`git checkout release/0.15.0`
+
+6. 创建并进入/paddle/build路径下：
+
+	`mkdir -p /paddle/build && cd /paddle/build`
+
+7. 使用以下命令安装相关依赖：
+
+	`pip install protobuf==3.1.0`
+	> 安装protobuf 3.1.0。
+
+	`apt install patchelf`
+	> 安装patchelf，PatchELF 是一个小而实用的程序，用于修改ELF可执行文件的动态链接器和RPATH。
+
+8. 执行cmake：     
+	
+	>具体编译选项含义请参见[编译选项表](#Compile)<!--TODO: Link 编译选项表到这里-->
+
+
+	*  对于需要编译**CPU版本PaddlePaddle**的用户：
+
+		`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF`
+
+
+	* 对于需要编译**GPU版本PaddlePaddle**的用户：
+
+		`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF`
+
+
+9. 执行编译：
+
+	`make -j$(nproc)`
+	> 使用多核编译
+
+10. 编译成功后进入`/paddle/build/python/dist`目录下找到生成的`.whl`包： `cd /paddle/build/python/dist`
+
+11. 在当前机器或目标机器安装编译好的`.whl`包：
+
+	`pip install （whl包的名字）`
+
+至此您已经成功使用Docker安装PaddlePaddle，您只需要进入Docker容器后运行PaddlePaddle即可，更多Docker使用请参见[Docker官方文档](https://docs.docker.com)。
+
+> 注：PaddlePaddle Docker镜像为了减小体积，默认没有安装`vim`，您可以在容器中执行 `apt-get install -y vim` 安装后，在容器中编辑代码。
+
+恭喜您，现在您已经完成使用Docker编译PaddlePaddle的过程。            
+
+<a name="ubt_source"></a>    
+	
+<br/><br/>
+##### ***本机编译***
+
+1. 检查您的计算机和操作系统是否符合我们支持的编译标准： `uname -m && cat /etc/*release`
+
+2. 更新`apt`的源： `apt update`
+
+2. 我们支持使用virtualenv进行编译安装，首先请使用以下命令创建一个名为`paddle-venv`的虚环境：
+
+	* 安装Python-dev: `apt install python-dev`
+
+	* 安装pip: `apt install python-pip` (请保证拥有9.0.1及以上版本的pip）
+
+	* 安装虚环境`virtualenv`以及`virtualenvwrapper`并创建名为`paddle-venv`的虚环境：
+
+		1.  `apt install virtualenv` 或 `pip install virtualenv`
+		2.  `apt install virtualenvwrapper` 或 `pip install virtualenvwrapper`
+		3.  找到`virtualenvwrapper.sh`： `find / -name virtualenvwrapper.sh`
+		4.  查看`virtualenvwrapper.sh`中的安装方法： `cat virtualenvwrapper.sh`
+		5.  按照`virtualenvwrapper.sh`中的安装方法安装`virtualwrapper`
+		6.  创建名为`paddle-venv`的虚环境： `mkvirtualenv paddle-venv`
+
+
+3. 进入虚环境：`workon paddle-venv`         
+
+
+4. **执行编译前**请您确认在虚环境中安装有[编译依赖表](#third_party)中提到的相关依赖：<!--TODO：Link 安装依赖表到这里-->
+
+	* 这里特别提供`patchELF`的安装方法，其他的依赖可以使用`apt install`或者`pip install` 后跟依赖名称和版本安装:
+
+		`apt install patchelf`
+		> 不能使用apt安装的用户请参见patchElF github[官方文档](https://gist.github.com/ruario/80fefd174b3395d34c14)
+
+5. 将PaddlePaddle的源码clone在当下目录下的Paddle的文件夹中，并进入Padde目录下：
+
+	- `git clone https://github.com/PaddlePaddle/Paddle.git`
+
+	- `cd Paddle`
+
+6. 切换到较稳定release分支下进行编译：
+
+	`git checkout release/0.15.0`
+
+7. 并且请创建并进入一个叫build的目录下：
+
+	`mkdir build && cd build`
+
+8. 执行cmake：       
+	
+	>具体编译选项含义请参见[编译选项表](#Compile)<!--TODO：Link 安装选项表到这里-->
+
+
+	*  对于需要编译**CPU版本PaddlePaddle**的用户：
+
+		`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF`.
+
+
+	* 对于需要编译**GPU版本PaddlePaddle**的用户：(*仅支持ubuntu16.04/14.04*)
+
+		1. 请确保您已经正确安装nccl2，或者按照以下指令安装nccl2（这里提供的是ubuntu 16.04，CUDA8，cuDNN7下nccl2的安装指令），更多版本的安装信息请参考NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download):      
+			i. `wget http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb`            
+			ii. `sudo apt-get install libnccl2=2.2.13-1+cuda8.0 libnccl-dev=2.2.13-1+cuda8.0` 
+		
+		2. 如果您已经正确安装了`nccl2`，就可以开始cmake了：
+
+		`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF`
+
+9. 使用以下命令来编译：
+
+	`make -j$(nproc)`
+
+10. 编译成功后进入`/paddle/build/python/dist`目录下找到生成的`.whl`包： `cd /paddle/build/python/dist`
+
+11. 在当前机器或目标机器安装编译好的`.whl`包：
+
+	`pip install （whl包的名字）`
+
+恭喜您，现在您已经完成使本机编译PaddlePaddle的过程了。
+
+<br/><br/>
+##### ***验证安装***
+安装完成后您可以使用：`python` 进入Python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
+
+<br/><br/>
+##### ***如何卸载PaddlePaddle***
+请使用以下命令卸载PaddlePaddle：
+
+* ***CPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle`
+
+* ***GPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle-gpu`
+
+
+<br/><br/>
+### **CentOS下从源码编译PaddlePaddle**
+
+本说明将介绍如何在*64位台式机或笔记本电脑*以及CentOS系统下编译PaddlePaddle，我们支持的Ubuntu系统需满足以下要求：
+
+* CentOS 7 / 6（这涉及到相关工具是否能被正常安装）
+
+#### 确定要编译的PaddlePaddle版本
+* **仅支持CPU的PaddlePaddle**。
+
+<!--* 支持GPU的PaddlePaddle，为了使得PaddlePaddle程序运行的更加迅速，我们通常使用GPU对PaddlePaddle程序进行加速，但安装GPU版本的PaddlePaddle需要先拥有满足以下条件的NVIDIA® GPU（具体安装流程和配置请务必参见NVIDIA官方文档：[For CUDA](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)，[For cuDNN](https://docs.nvidia.com/deeplearning/sdk/cudnn-install/)）
+	* *Cuda 工具包9.0配合cuDNN v7*
+	* *Cuda 工具包8.0配合cuDNN v7*
+	* *GPU运算能力超过1.0的硬件设备*-->
+
+#### 选择如何编译PaddlePaddle
+我们在CentOS的系统下提供2种编译方式：
+
+* Docker源码编译（不支持CentOS 6 / 7的GPU版本）
+* 直接本机源码编译（不支持CentOS 6的全部版本以及CentOS 7的GPU版本）
+
+我们更加推荐**使用Docker进行编译**，因为我们在把工具和配置都安装在一个 Docker image 里。这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。        
+
+
+
+同样对于那些出于各种原因不能够安装Docker的用户我们也提供了可以从**本机直接源码编译**的方法，但是由于在本机上的情况更加复杂，因此我们只支持特定的系统。            
+
+<a name="ct_docker"></a>
+
+
+<br/><br/>
+##### ***使用Docker进行编译***
+
+为了更好的使用Docker并避免发生问题，我们推荐使用**最高版本的Docker**，关于**安装和使用Docker**的细节请参阅Docker[官方文档](https://docs.docker.com/install/)。   
+
+
+<!--TODO add the following back when support gpu version on Cent-->
+
+当您已经**正确安装Docker**后你就可以开始**使用Docker编译PaddlePaddle**啦：
+
+1. 请首先选择您希望储存PaddlePaddle的路径，然后在该路径下使用以下命令将PaddlePaddle的源码从github克隆到本地当前目录下名为Paddle的文件夹中：
+
+	`git clone https://github.com/PaddlePaddle/Paddle.git`
+
+2. 进入Paddle目录下： `cd Paddle`
+
+3. 利用我们提供的镜像（使用该命令您可以不必提前下载镜像）：
+
+	`docker run --name paddle-test -v $PWD:/paddle --network=host -it hub.baidubce.com/paddlepaddle/paddle:latest-dev /bin/bash`
+	> --name paddle-test为您创建的Docker容器命名为paddle-test，-v $PWD:/paddle 将当前目录挂载到Docker容器中的/paddle目录下（Linux中PWD变量会展开为当前路径的[绝对路径](https://baike.baidu.com/item/绝对路径/481185)），-it 与宿主机保持交互状态，`hub.baidubce.com/paddlepaddle/paddle` 使用名为`hub.baidubce.com/paddlepaddle/paddle:latest-dev`的镜像创建Docker容器，/bin/bash 进入容器后启动/bin/bash命令。
+
+4. 进入Docker后进入paddle目录下：`cd paddle`
+
+5. 切换到较稳定release分支下进行编译：
+
+	`git checkout release/0.15.0`
+
+6. 创建并进入/paddle/build路径下：
+
+	`mkdir -p /paddle/build && cd /paddle/build`
+
+7. 使用以下命令安装相关依赖：
+
+	`pip install protobuf==3.1.0`
+	> 安装protobuf 3.1.0。
+
+	`apt install patchelf`
+	> 安装patchelf，PatchELF 是一个小而实用的程序，用于修改ELF可执行文件的动态链接器和RPATH。
+
+8. 执行cmake：       
+	
+	>具体编译选项含义请参见[编译选项表](#Compile)
+	
+	
+	*  对于需要编译**CPU版本PaddlePaddle**的用户：      
+
+		
+		`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF`
+	
+	
+	>> 我们目前不支持CentOS下GPU版本PaddlePaddle的编译     
+		
+9. 执行编译：
+
+	`make -j$(nproc)`
+	> 使用多核编译
+
+10. 编译成功后进入`/paddle/build/python/dist`目录下找到生成的`.whl`包： `cd /paddle/build/python/dist`
+
+11. 在当前机器或目标机器安装编译好的`.whl`包：
+
+	`pip install （whl包的名字）`
+
+至此您已经成功使用Docker安装PaddlePaddle，您只需要进入Docker容器后运行PaddlePaddle即可，更多Docker使用请参见[Docker官方文档](https://docs.docker.com)。
+
+> 注：PaddlePaddle Docker镜像为了减小体积，默认没有安装`vim`，您可以在容器中执行 `apt-get install -y vim` 安装后，在容器中编辑代码。
+
+恭喜您，现在您已经完成使用Docker编译PaddlePaddle的过程。        
+
+
+
+      
+
+<a name="ct_source"></a>
+
+
+<br/><br/>
+##### ***本机编译***
+
+1. 检查您的计算机和操作系统是否符合我们支持的编译标准： `uname -m && cat /etc/*release`
+
+2. 更新`yum`的源： `yum update`, 并添加必要的yum源：`yum install -y epel-release`
+
+3. 安装必要的工具`bzip2`以及`make`： `yum install -y bzip2` ， `yum install -y make`
+
+2. 我们支持使用virtualenv进行编译安装，首先请使用以下命令创建一个名为`paddle-venv`的虚环境：
+
+	* 安装Python-dev: `yum install python-devel`
+
+	* 安装pip: `yum install python-pip` (请保证拥有9.0.1及以上的pip版本）
+
+	* 安装虚环境`virtualenv`以及`virtualenvwrapper`并创建名为`paddle-venv`的虚环境：
+
+		1.  `pip install virtualenv` 或 `pip install virtualenv`
+		2.  `pip install virtualenvwrapper` 或 `pip install virtualenvwrapper`
+		3.  找到`virtualenvwrapper.sh`： `find / -name virtualenvwrapper.sh`
+		4.  查看`virtualenvwrapper.sh`中的安装方法： `cat vitualenvwrapper.sh`
+		5.  安装`virtualwrapper`
+		6.  创建名为`paddle-venv`的虚环境： `mkvirtualenv paddle-venv`
+
+
+3. 进入虚环境：`workon paddle-venv`         
+
+
+4. **执行编译前**请您确认在虚环境中安装有[编译依赖表](#third_party)中提到的相关依赖：<!--TODO：Link 安装依赖表到这里-->
+
+	* 这里特别提供`patchELF`的安装方法，其他的依赖可以使用`yum install`或者`pip install` 后跟依赖名称和版本安装:
+
+		`yum install patchelf`
+		> 不能使用apt安装的用户请参见patchElF github[官方文档](https://gist.github.com/ruario/80fefd174b3395d34c14)
+
+5. 将PaddlePaddle的源码clone在当下目录下的Paddle的文件夹中，并进入Padde目录下：
+
+	- `git clone https://github.com/PaddlePaddle/Paddle.git`
+
+	- `cd Paddle`
+
+6. 切换到较稳定release分支下进行编译：
+
+	`git checkout release/0.15.0`
+
+7. 并且请创建并进入一个叫build的目录下：
+
+	`mkdir build && cd build`
+
+8. 执行cmake：       
+	
+	>具体编译选项含义请参见[编译选项表](#Compile)<!--TODO：Link 安装选项表到这里-->
+
+
+	*  对于需要编译**CPU版本PaddlePaddle**的用户：
+
+		`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF`.
+	
+		
+
+
+9. 使用以下命令来编译：
+
+	`make -j$(nproc)`
+
+10. 编译成功后进入`/paddle/build/python/dist`目录下找到生成的`.whl`包： `cd /paddle/build/python/dist`
+
+11. 在当前机器或目标机器安装编译好的`.whl`包：
+
+	`pip install （whl包的名字）`
+
+恭喜您，现在您已经完成使本机编译PaddlePaddle的过程了。
+
+
+
+<br/><br/>
+##### ***验证安装***
+安装完成后您可以使用：`python` 进入Python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
+
+<br/><br/>
+##### ***如何卸载PaddlePaddle***
+请使用以下命令卸载PaddlePaddle：
+
+* ***CPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle`
+
+
+
+
+<br/><br/>
+### **MacOS下从源码编译PaddlePaddle**
+
+本说明将介绍如何在*64位台式机或笔记本电脑*以及MacOS系统下编译PaddlePaddle，我们支持的MacOS系统需满足以下要求：
+
+* MacOS 10.12/10.13（这涉及到相关工具是否能被正常安装）
+
+#### 确定要编译的PaddlePaddle版本
+* **仅支持CPU的PaddlePaddle**。
+
+<!--* 支持GPU的PaddlePaddle，为了使得PaddlePaddle程序运行的更加迅速，我们通常使用GPU对PaddlePaddle程序进行加速，但安装GPU版本的PaddlePaddle需要先拥有满足以下条件的NVIDIA® GPU（具体安装流程和配置请务必参见NVIDIA官方文档：[For CUDA](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)，[For cuDNN](https://docs.nvidia.com/deeplearning/sdk/cudnn-install/)）
+	* *Cuda 工具包9.0配合cuDNN v7*
+	* *Cuda 工具包8.0配合cuDNN v7*
+	* *GPU运算能力超过1.0的硬件设备*-->
+
+#### 选择如何编译PaddlePaddle
+在MacOS 10.12/10.13的系统下我们提供1种编译方式：
+
+<!--* 直接本机源码编译-->
+* Docker源码编译
+
+
+
+
+
+我们更加推荐**使用Docker进行编译**，因为我们在把工具和配置都安装在一个 Docker image 里。这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。        
+
+
+
+
+       
+
+<a name="mac_docker"></a>
+
+
+
+<br/><br/>
+##### ***使用Docker进行编译***
+
+为了更好的使用Docker并避免发生问题，我们推荐使用**最高版本的Docker**，关于**安装和使用Docker**的细节请参阅Docker[官方文档](https://docs.docker.com/install/)。
+> 请注意，在MacOS系统下登陆docker需要使用您的dockerID进行登录，否则将出现`Authenticate Failed`错误。       
+
+
+当您已经**正确安装Docker**后你就可以开始**使用Docker编译PaddlePaddle**啦：
+
+1. 进入Mac的终端
+
+2. 请选择您希望储存PaddlePaddle的路径，然后在该路径下使用以下命令将PaddlePaddle的源码从github克隆到本地当前目录下名为Paddle的文件夹中：
+
+	`git clone https://github.com/PaddlePaddle/Paddle.git`
+
+3. 进入Paddle目录下： `cd Paddle`
+
+4. 利用我们提供的镜像（使用该命令您可以不必提前下载镜像）：
+
+	`docker run --name paddle-test -v $PWD:/paddle --network=host -it hub.baidubce.com/paddlepaddle/paddle:latest-dev /bin/bash`
+	> --name paddle-test为您创建的Docker容器命名为paddle-test，-v $PWD:/paddle 将当前目录挂载到Docker容器中的/paddle目录下（Linux中PWD变量会展开为当前路径的[绝对路径](https://baike.baidu.com/item/绝对路径/481185)），-it 与宿主机保持交互状态，`hub.baidubce.com/paddlepaddle/paddle:latest-dev` 使用名为`hub.baidubce.com/paddlepaddle/paddle:latest-dev`的镜像创建Docker容器，/bin/bash 进入容器后启动/bin/bash命令。
+
+5. 进入Docker后进入paddle目录下：`cd paddle`
+
+7. 切换到较稳定release分支下进行编译：
+
+	`git checkout release/0.15.0`
+
+8. 创建并进入/paddle/build路径下：
+
+	`mkdir -p /paddle/build && cd /paddle/build`
+
+9. 使用以下命令安装相关依赖：
+
+	`pip install protobuf==3.1.0`
+	> 安装protobuf 3.1.0。
+
+	`apt install patchelf`
+	> 安装patchelf，PatchELF 是一个小而实用的程序，用于修改ELF可执行文件的动态链接器和RPATH。
+
+10. 执行cmake：      
+	
+	>具体编译选项含义请参见[编译选项表](#Compile)<!--TODO： Link 编译选项表到这里-->
+
+
+	*  对于需要编译**CPU版本PaddlePaddle**的用户：
+
+		`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF`
+		> 我们目前不支持CentOS下GPU版本PaddlePaddle的编译
+
+
+
+
+11. 执行编译：
+
+	`make -j$(nproc)`
+	> 使用多核编译
+
+12. 编译成功后进入`/paddle/build/python/dist`目录下找到生成的`.whl`包： `cd /paddle/build/python/dist`
+
+13. 在当前机器或目标机器安装编译好的`.whl`包：
+
+	`pip install （whl包的名字）`
+
+至此您已经成功使用Docker安装PaddlePaddle，您只需要进入Docker容器后运行PaddlePaddle即可，更多Docker使用请参见[Docker官方文档](https://docs.docker.com)。
+
+> 注：PaddlePaddle Docker镜像为了减小体积，默认没有安装`vim`，您可以在容器中执行 `apt-get install -y vim` 安装后，在容器中编辑代码。
+
+恭喜您，现在您已经完成使用Docker编译PaddlePaddle的过程。
+
+
+
+
+<br/><br/>
+##### ***验证安装***
+安装完成后您可以使用：`python` 进入Python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
+
+<br/><br/>
+##### ***如何卸载PaddlePaddle***
+请使用以下命令卸载PaddlePaddle：
+
+* ***CPU版本的PaddlePaddle***: `pip uninstall PaddlePaddle`
+
+
+
+
+
+<a name="FAQ"></a>
+</br></br>
+## **FAQ**
+- CentOS6下如何编译python2.7为共享库? 
+	
+	> 使用以下指令：
+	
+		./configure --prefix=/usr/local/python2.7 --enable-shared   
+		make && make install   
+
+<!--TODO please add more F&Q parts here-->
+
+- Ubuntu18.04下libidn11找不到？
+	
+	> 使用以下指令：
+	
+		apt install libidn11   
+
+- Ubuntu编译时出现大量的代码段不能识别？
+	
+	> 这可能是由于cmake版本不匹配造成的，请在gcc的安装目录下使用以下指令：
+		
+		apt install gcc-4.8 g++-4.8
+		cp gcc gcc.bak
+		cp g++ g++.bak
+		rm gcc
+		rm g++
+		ln -s gcc-4.8 gcc
+		ln -s g++-4.8 g++
+
+        
+
+
+
+
+- 遇到paddlepaddle*.whl is not a supported wheel on this platform？
+	> 出现这个问题的主要原因是，没有找到和当前系统匹配的paddlepaddle安装包。 请检查Python版本是否为2.7系列。另外最新的pip官方源中的安装包默认是manylinux1标准， 需要使用最新的pip (>9.0.0) 才可以安装。您可以执行以下指令更新您的pip：     
+	
+	pip install --upgrade pip     
+
+	> 或者：     
+	
+	python -c "import pip; print(pip.pep425tags.get_supported())"    
+
+	> 如果系统支持的是 linux_x86_64 而安装包是 manylinux1_x86_64 ，需要升级pip版本到最新； 如果系统支持 manylinux1_x86_64 而安装包	 （本地）是 linux_x86_64， 可以重命名这个whl包为 manylinux1_x86_64 再安装。
+
+- 使用Docker编译出现问题？
+	
+	> 请参照GitHub上[Issue12079](https://github.com/PaddlePaddle/Paddle/issues/12079)
+
+- 什么是 Docker?
+
+  如果您没有听说 Docker，可以把它想象为一个类似 virtualenv 的系统，但是虚拟的不仅仅是 Python 的运行环境。
+
+- Docker 还是虚拟机？
+
+  有人用虚拟机来类比 Docker。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。
+
+- 为什么用 Docker?
+
+  把工具和配置都安装在一个 Docker image 里可以标准化编译环境。这样如果遇到问题，其他人可以复现问题以便帮助。
+
+  另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。
+
+- 可以选择不用Docker吗？
+
+  当然可以。大家可以用把开发工具安装进入 Docker image 一样的方式，把这些工具安装到本机。这篇文档介绍基于 Docker 的开发流程，是因为这个流程比其他方法都更简便。
+
+- 学习 Docker 有多难？
+
+  理解 Docker 并不难，大概花十分钟看一下[这篇文章](https://zhuanlan.zhihu.com/p/19902938)。
+  这可以帮您省掉花一小时安装和配置各种开发工具，以及切换机器时需要新安装的辛苦。别忘了 PaddlePaddle 更新可能导致需要新的开发工具。更别提简化问题复现带来的好处了。
+
+- 可以用 IDE 吗？
+
+  当然可以，因为源码就在本机上。IDE 默认调用 make 之类的程序来编译源码，我们只需要配置 IDE 来调用 Docker 命令编译源码即可。
+
+  很多 PaddlePaddle 开发者使用 Emacs。他们在自己的 `~/.emacs` 配置文件里加两行
+
+    (global-set-key "\C-cc" 'compile)
+    (setq compile-command "docker run --rm -it -v $(git rev-parse --show-toplevel):/paddle paddle:dev")
+
+  就可以按 `Ctrl-C` 和 `c` 键来启动编译了。
+
+- 可以并行编译吗？
+
+  是的。我们的 Docker image 运行一个 [Bash 脚本](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/paddle/scripts/paddle_build.sh)。这个脚本调用`make -j$(nproc)` 来启动和 CPU 核一样多的进程来并行编译。
+
+- Docker 需要 sudo？
+
+  如果用自己的电脑开发，自然也就有管理员权限（sudo）了。如果用公用的电脑开发，需要请管理员安装和配置好 Docker。此外，PaddlePaddle 项目在努力开始支持其他不需要 sudo 的集装箱技术，比如 rkt。
+
+- 在 Windows/MacOS 上编译很慢？
+
+  Docker 在 Windows 和 MacOS 都可以运行。不过实际上是运行在一个 Linux 虚拟机上。可能需要注意给这个虚拟机多分配一些 CPU 和内存，以保证编译高效。具体做法请参考[issue627](https://github.com/PaddlePaddle/Paddle/issues/627)。
+
+- 磁盘不够？
+
+  本文中的例子里， `docker run` 命令里都用了 `--rm` 参数，这样保证运行结束之后的 containers 不会保留在磁盘上。可以用 `docker ps -a` 命令看到停止后但是没有删除的 containers。 `docker build` 命令有时候会产生一些中间结果，是没有名字的 images，也会占用磁盘。可以参考 [这篇文章](https://zaiste.net/posts/removing_docker_containers) 来清理这些内容。
+
+- 在DockerToolbox下使用book时`http://localhost:8888/`无法打开？
+	
+   需要将localhost替换成虚拟机ip，一般需要在浏览器中输入：`http://192.168.99.100:8888/`
+
+- pip install gpu版本的PaddlePaddle后运行出现SegmentFault如下：
+   
+  	 @ 0x7f6c8d214436 paddle::platform::EnforceNotMet::EnforceNotMet()
+	 
+   	 @ 0x7f6c8dfed666 paddle::platform::GetCUDADeviceCount() 
+	 
+  	 @ 0x7f6c8d2b93b6 paddle::framework::InitDevices()
+   
+   出现这个问题原因主要是由于您的显卡驱动低于对应CUDA版本的要求，请保证您的显卡驱动支持所使用的CUDA版本
+
+<a name="third_party"></a>
+</br></br>
+## 附录
+
+### **编译依赖表**
+
+<p align="center">
+<table>
+	<thead>
+	<tr>
+		<th> 依赖包名称 </th>
+		<th> 版本 </th>
+		<th> 说明 </th>
+		<th> 安装命令 </th>
+	</tr>
+	</thead>
+	<tbody>
+	<tr>
+		<td> CMake </td>
+		<td> 3.4 </td>
+		<td>  </td>
+		<td>  </td>
+	</tr>
+	<tr>
+		<td> GCC </td>
+		<td> 4.8 / 5.4 </td>
+		<td>  推荐使用CentOS的devtools2 </td>
+		<td>  </td>
+	</tr>
+		<tr>
+		<td> Python </td>
+		<td> 2.7.x. </td>
+		<td> 依赖libpython2.7.so </td>
+		<td> <code> apt install python-dev </code> 或 <code> yum install python-devel </code></td>
+	</tr>
+	<tr>
+		<td> SWIG </td>
+		<td> 最低 2.0 </td>
+		<td>  </td>
+		<td> <code>apt install swig </code> 或 <code> yum install swig </code> </td>
+	</tr>
+	<tr>
+		<td> wget </td>
+		<td> any </td>
+		<td>  </td>
+		<td> <code> apt install wget </code>  或 <code> yum install wget </code> </td>
+	</tr>
+	<tr>
+		<td> openblas </td>
+		<td> any </td>
+		<td>  </td>
+		<td>  </td>
+	</tr>
+	<tr>
+		<td> pip </td>
+		<td> 最低9.0.1 </td>
+		<td>  </td>
+		<td> <code> apt install python-pip </code> 或 <code> yum install Python-pip </code> </td>
+	</tr>
+	<tr>
+		<td> numpy </td>
+		<td> >=1.12.0 </td>
+		<td>  </td>
+		<td> <code> pip install numpy==1.14.0 </code> </td>
+	</tr>
+	<tr>
+		<td> protobuf </td>
+		<td> 3.1.0 </td>
+		<td>  </td>
+		<td> <code> pip install protobuf==3.1.0 </code> </td>
+	</tr>
+	<tr>
+		<td> wheel </td>
+		<td> any </td>
+		<td>  </td>
+		<td> <code> pip install wheel </code> </td>
+	</tr>
+	<tr>
+		<td> patchELF </td>
+		<td> any </td>
+		<td>  </td>
+		<td> <code> apt install patchelf </code> 或参见github <a href="https://gist.github.com/ruario/80fefd174b3395d34c14">patchELF 官方文档</a></td>
+	</tr>
+	<tr>
+		<td> go </td>
+		<td> >=1.8 </td>
+		<td> 可选 </td>
+		<td>  </td>
+	</tr>
+	</tbody>
+</table>
+</p>
+
+
+***
+<a name="Compile"></a>
+</br></br>
+### **编译选项表**
+
+<p align="center">
+<table>
+	<thead>
+	<tr>
+		<th> 选项 </th>
+		<th> 说明 </th>
+		<th> 默认值 </th>
+	</tr>
+	</thead>
+	<tbody>
+	<tr>
+		<td> WITH_GPU </td>
+		<td> 是否支持GPU </td>
+		<td> ON </td>
+	</tr>
+	<tr>
+		<td> WITH_C_API </td>
+		<td> 是否仅编译CAPI </td>
+		<td>  OFF </td>
+	</tr>
+		<tr>
+		<td> WITH_DOUBLE </td>
+		<td> 是否使用双精度浮点数 </td>
+		<td> OFF </td>
+	</tr>
+	<tr>
+		<td> WITH_DSO </td>
+		<td> 是否运行时动态加载CUDA动态库，而非静态加载CUDA动态库 </td>
+		<td> ON </td>
+	</tr>
+	<tr>
+		<td> WITH_AVX </td>
+		<td> 是否编译含有AVX指令集的PaddlePaddle二进制文件 </td>
+		<td> ON </td>
+	</tr>
+	<tr>
+		<td> WITH_PYTHON </td>
+		<td> 是否内嵌PYTHON解释器 </td>
+		<td> ON </td>
+	</tr>
+	<tr>
+		<td> WITH_STYLE_CHECK </td>
+		<td> 是否编译时进行代码风格检查 </td>
+		<td> ON </td>
+	</tr>
+	<tr>
+		<td> WITH_TESTING </td>
+		<td> 是否开启单元测试 </td>
+		<td> OFF </td>
+	</tr>
+	<tr>
+		<td> WITH_DOC </td>
+		<td> 是否编译中英文文档 </td>
+		<td> OFF </td>
+	</tr>
+	<tr>
+		<td> WITH_SWIG_PY </td>
+		<td> 是否编译PYTHON的SWIG接口，该接口可用于预测和定制化训练 </td>
+		<td> Auto </td>
+	<tr>
+		<td> WITH_GOLANG </td>
+		<td> 是否编译go语言的可容错parameter server </td>
+		<td> OFF </td>
+	</tr>
+	<tr>
+		<td> WITH_MKL </td>
+		<td> 是否使用MKL数学库，如果为否则是用OpenBLAS </td>
+		<td> ON </td>
+	</tr>
+   </tbody>
+</table>
+</p>
+
+
+
+
+
+**BLAS**
+
+PaddlePaddle支持 [MKL](https://software.intel.com/en-us/mkl) 和 [OpenBlAS](http://www.openblas.net) 两种BLAS库。默认使用MKL。如果使用MKL并且机器含有AVX2指令集，还会下载MKL-DNN数学库，详细参考[这里](https://github.com/PaddlePaddle/Paddle/tree/develop/doc/design/mkldnn#cmake) 。
+
+如果关闭MKL，则会使用OpenBLAS作为BLAS库。
+
+**CUDA/cuDNN**
+
+PaddlePaddle在编译时/运行时会自动找到系统中安装的CUDA和cuDNN库进行编译和执行。 使用参数 `-DCUDA_ARCH_NAME=Auto` 可以指定开启自动检测SM架构，加速编译。
+
+PaddlePaddle可以使用cuDNN v5.1之后的任何一个版本来编译运行，但尽量请保持编译和运行使用的cuDNN是同一个版本。 我们推荐使用最新版本的cuDNN。
+
+**编译选项的设置**
+
+PaddePaddle通过编译时指定路径来实现引用各种BLAS/CUDA/cuDNN库。cmake编译时，首先在系统路径（ `/usr/liby` 和 `/usr/local/lib` ）中搜索这几个库，同时也会读取相关路径变量来进行搜索。 通过使用`-D`命令可以设置，例如：
+
+> `cmake .. -DWITH_GPU=ON -DWITH_TESTING=OFF -DCUDNN_ROOT=/opt/cudnnv5`
+
+**注意**：这几个编译选项的设置，只在第一次cmake的时候有效。如果之后想要重新设置，推荐清理整个编译目录（ rm -rf ）后，再指定。
+
+
+***
+<a name="whls"></a>
+</br></br>
+### **安装包列表**   
+
+<p align="center">
+<table>
+	<thead>
+	<tr>
+		<th> 版本号 </th>
+		<th> 版本说明 </th>
+	</tr>
+	</thead>
+	<tbody>
+	<tr>
+		<td> paddlepaddle-gpu==0.15.0 </td>
+		<td> 使用CUDA 9.0和cuDNN 7编译的0.15.0版本 </td>
+	</tr>
+	<tr>
+		<td> paddlepaddle-gpu==0.15.0.post87 </td>
+		<td> 使用CUDA 8.0和cuDNN 7编译的0.15.0版本 </td>
+	</tr>
+		<tr>
+		<td> paddlepaddle-gpu==0.15.0.post85 </td>
+		<td> 使用CUDA 8.0和cuDNN 5编译的0.15.0版本 </td>
+	</tr>
+	<tr>
+		<td> paddlepaddle-gpu==0.13.0 </td>
+		<td> 使用CUDA 9.0和cuDNN 7编译的0.13.0版本 </td>
+	</tr>
+	<tr>
+		<td> paddlepaddle-gpu==0.12.0 </td>
+		<td> 使用CUDA 8.0和cuDNN 5编译的0.12.0版本 </td>
+	</tr>
+	<tr>
+		<td> paddlepaddle-gpu==0.11.0.post87 </td>
+		<td> 使用CUDA 8.0和cuDNN 7编译的0.11.0版本 </td>
+	</tr>
+	<tr>
+		<td> paddlepaddle-gpu==0.11.0.post85 </td>
+		<td> 使用CUDA 8.0和cuDNN 5编译的0.11.0版本 </td>
+	</tr>
+	<tr>
+		<td> paddlepaddle-gpu==0.11.0 </td>
+		<td> 使用CUDA 7.5和cuDNN 5编译的0.11.0版本 </td>
+	</tr>
+   </tbody>
+</table>
+</p>
+
+
+您可以在 [Release History](https://pypi.org/project/paddlepaddle-gpu/#history) 中找到PaddlePaddle-gpu的各个发行版本。
+
+***
+<a name="dockers"></a>
+</br></br>
+### **安装镜像表及简介**   
+<p align="center">
+<table>
+	<thead>
+	<tr>
+		<th> 版本号 </th>
+		<th> 版本说明 </th>
+	</tr>
+	</thead>
+	<tbody>
+	<tr>
+		<td> hub.baidubce.com/paddlepaddle/paddle:latest </td>
+		<td> 最新的预先安装好PaddlePaddle CPU版本的镜像 </td>
+	</tr>
+	<tr>
+		<td> hub.baidubce.com/paddlepaddle/paddle:latest-dev </td>
+		<td> 最新的PaddlePaddle的开发环境 </td>
+	</tr>
+		<tr>
+		<td> hub.baidubce.com/paddlepaddle/paddle:[Version] </td>
+		<td> 将version换成具体的版本，历史版本的预安装好PaddlePaddle的镜像 </td>
+	</tr>
+	<tr>
+		<td> hub.baidubce.com/paddlepaddle/paddle:latest-gpu </td>
+		<td> 最新的预先安装好PaddlePaddle GPU版本的镜像 </td>
+	</tr>
+   </tbody>
+</table>
+</p>
+
+
+您可以在 [DockerHub](https://hub.docker.com/r/paddlepaddle/paddle/tags/) 中找到PaddlePaddle的各个发行的版本的docker镜像。
+
+
+
+
+***
+<a name="ciwhls"></a>
+</br></br>
+### **多版本whl包列表**   
+<p align="center">
+<table>
+	<thead>
+	<tr>
+		<th> 版本说明 </th>
+		<th> cp27-cp27mu </th>
+		<th> cp27-cp27m </th>
+	</tr>
+	</thead>
+	<tbody>
+	<tr>
+		<td> cpu_avx_mkl </td>
+		<td> <a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_CpuAvxCp27cp27mu/.lastSuccessful/paddlepaddle-latest-cp27-cp27mu-linux_x86_64.whl">	paddlepaddle-latest-cp27-cp27mu-linux_x86_64.whl</a></td>
+		<td> <a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_CpuAvxCp27cp27mu/.lastSuccessful/paddlepaddle-latest-cp27-cp27m-linux_x86_64.whl">	paddlepaddle-latest-cp27-cp27mu-linux_x86_64.whl</a></td>
+	</tr>
+	<tr>
+		<td> cpu_avx_mkl </td>
+		<td> <a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_CpuAvxOpenblas/.lastSuccessful/paddlepaddle-latest-cp27-cp27mu-linux_x86_64.whl">	paddlepaddle-latest-cp27-cp27mu-linux_x86_64.whl</a></td>
+		<td> <a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_CpuAvxOpenblas/.lastSuccessful/paddlepaddle-latest-cp27-cp27m-linux_x86_64.whl">	paddlepaddle-latest-cp27-cp27m-linux_x86_64.whl</a></td>
+	</tr>
+		<tr>
+		<td> cpu_noavx_openblas </td>
+		<td> <a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_CpuNoavxOpenblas/.lastSuccessful/paddlepaddle-latest-cp27-cp27mu-linux_x86_64.whl">	paddlepaddle-latest-cp27-cp27mu-linux_x86_64.whl</a></td>
+		<td><a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_CpuNoavxOpenblas/.lastSuccessful/paddlepaddle-latest-cp27-cp27m-linux_x86_64.whl">	paddlepaddle-latest-cp27-cp27m-linux_x86_64.whl</a></td>
+	</tr>
+	<tr>
+		<td> cuda8.0_cudnn5_avx_mkl </td>
+		<td> <a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_Cuda80cudnn5cp27cp27mu/.lastSuccessful/paddlepaddle_gpu-latest-cp27-cp27mu-linux_x86_64.whl">	paddlepaddle_gpu-latest-cp27-cp27mu-linux_x86_64.whl</a></td>
+		<td><a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_Cuda80cudnn5cp27cp27mu/.lastSuccessful/paddlepaddle_gpu-latest-cp27-cp27m-linux_x86_64.whl">	paddlepaddle_gpu-latest-cp27-cp27m-linux_x86_64.whl</a></td>
+	</tr>
+	<tr>
+		<td> cuda8.0_cudnn7_avx_mkl </td>
+		<td> <a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_Cuda8cudnn7cp27cp27mu/.lastSuccessful/paddlepaddle_gpu-latest-cp27-cp27mu-linux_x86_64.whl">	paddlepaddle_gpu-latest-cp27-cp27mu-linux_x86_64.whl</a></td>
+		<td><a href="https://guest@paddleci.ngrok.io/repository/download/Manylinux1_Cuda8cudnn7cp27cp27mu/.lastSuccessful/paddlepaddle_gpu-latest-cp27-cp27m-linux_x86_64.whl">	paddlepaddle_gpu-latest-cp27-cp27m-linux_x86_64.whl</a></td>
+	</tr>
+   </tbody>
+</table>
+</p>        
+
+
+  
+  
+  
+
+
+<!--TODO this part should be in a new webpage-->
+
+</br></br>
+
+### 在Docker中执行PaddlePaddle训练程序     
+
+***
+
+假设您已经在当前目录（比如在/home/work）编写了一个PaddlePaddle的程序: `train.py` （可以参考
+[PaddlePaddleBook](http://www.paddlepaddle.org/docs/develop/book/01.fit_a_line/index.cn.html)
+编写），就可以使用下面的命令开始执行训练：
+
+     cd /home/work
+     docker run -it -v $PWD:/work hub.baidubce.com/paddlepaddle/paddle /work/train.py
+
+上述命令中，`-it` 参数说明容器已交互式运行；`-v $PWD:/work`
+指定将当前路径（Linux中PWD变量会展开为当前路径的绝对路径）挂载到容器内部的:`/work`
+目录: `hub.baidubce.com/paddlepaddle/paddle` 指定需要使用的容器； 最后`/work/train.py`为容器内执行的命令，即运行训练程序。
+
+当然，您也可以进入到Docker容器中，以交互式的方式执行或调试您的代码：
+
+     docker run -it -v $PWD:/work hub.baidubce.com/paddlepaddle/paddle /bin/bash
+     cd /work
+     python train.py
+
+**注：PaddlePaddle Docker镜像为了减小体积，默认没有安装vim，您可以在容器中执行** `apt-get install -y vim` **安装后，在容器中编辑代码。**
+
+</br></br>
+
+### 使用Docker启动PaddlePaddle Book教程
+
+***
+
+使用Docker可以快速在本地启动一个包含了PaddlePaddle官方Book教程的Jupyter Notebook，可以通过网页浏览。
+PaddlePaddle Book是为用户和开发者制作的一个交互式的Jupyter Notebook。
+如果您想要更深入了解deep learning，PaddlePaddle Book一定是您最好的选择。
+大家可以通过它阅读教程，或者制作和分享带有代码、公式、图表、文字的交互式文档。
+
+我们提供可以直接运行PaddlePaddle Book的Docker镜像，直接运行：
+
+`docker run -p 8888:8888 hub.baidubce.com/paddlepaddle/book`
+
+国内用户可以使用下面的镜像源来加速访问：
+
+`docker run -p 8888:8888 hub.baidubce.com/paddlepaddle/book`
+
+然后在浏览器中输入以下网址：
+
+`http://localhost:8888/`
+
+就这么简单，享受您的旅程！如有其他问题请参见[FAQ](#FAQ)
+
+</br></br>
+### 使用Docker执行GPU训练
+
+***
+
+为了保证GPU驱动能够在镜像里面正常运行，我们推荐使用
+[nvidia-docker](https://github.com/NVIDIA/nvidia-docker)来运行镜像。
+请不要忘记提前在物理机上安装GPU最新驱动。
+
+`nvidia-docker run -it -v $PWD:/work hub.baidubce.com/paddlepaddle/paddle:latest-gpu /bin/bash`
+
+**注: 如果没有安装nvidia-docker，可以尝试以下的方法，将CUDA库和Linux设备挂载到Docker容器内：**
+
+     export CUDA_SO="$(\ls /usr/lib64/libcuda* | xargs -I{} echo '-v {}:{}') \
+     $(\ls /usr/lib64/libnvidia* | xargs -I{} echo '-v {}:{}')"
+     export DEVICES=$(\ls /dev/nvidia* | xargs -I{} echo '--device {}:{}')
+     docker run ${CUDA_SO} \
+      ${DEVICES} -it hub.baidubce.com/paddlepaddle/paddle:latest-gpu
+
+
+**关于AVX：**
+
+AVX是一种CPU指令集，可以加速PaddlePaddle的计算。最新的PaddlePaddle Docker镜像默认
+是开启AVX编译的，所以，如果您的电脑不支持AVX，需要单独[编译](/build_from_source_cn.html) PaddlePaddle为no-avx版本。
+
+以下指令能检查Linux电脑是否支持AVX：
+
+`if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi`
+
+如果输出是No，就需要选择使用no-AVX的镜像
diff --git a/doc/fluid/new_docs/beginners_guide/install/install_doc.rst b/doc/fluid/new_docs/beginners_guide/install/install_doc.rst
deleted file mode 100644
index 8a66a95f45..0000000000
--- a/doc/fluid/new_docs/beginners_guide/install/install_doc.rst
+++ /dev/null
@@ -1,543 +0,0 @@
-.. _how_to_install:
-
-安装说明
-^^^^^^^^
-
-若您的系统为Linux或Windows，您可以使用我们提供的安装包来安装PaddlePaddle。
-
-对于MacOS系统，我们暂未提供安装包，您可以使用 **从源码编译** 的方式安装。
-
-
-.. _install_linux:
-
-在Linux安装PaddlePaddle
---------
-
-推荐您使用 `pip <https://pypi.org/project/pip/>`_
-安装，它是Linux系统下最简单的安装方式。
-
-注意事项：
-
-- PaddlePaddle Python API 依赖Python 2.7版本。
-
-执行下面的命令即可在当前机器上安装PaddlePaddle的运行时环境，并自动下载安装依赖软件。
-
-  .. code-block:: bash
-
-     pip install paddlepaddle
-
-您可以通过指定版本号来安装其它版本，例如：
-
-  .. code-block:: bash
-
-      pip install paddlepaddle==0.13.0
-
-
-如果需要安装支持GPU的版本（cuda9.0_cudnn7_avx_openblas），需要执行：
-
-  .. code-block:: bash
-
-     pip install paddlepaddle-gpu
-
-PaddlePaddle针对不同需求提供了更多版本的安装包，部分列表如下：
-
-=================================   ========================================
-版本号                               版本说明
-=================================   ========================================
-paddlepaddle-gpu==0.14.0            使用CUDA 9.0和cuDNN 7编译的0.14.0版本
-paddlepaddle-gpu==0.14.0.post87     使用CUDA 8.0和cuDNN 7编译的0.14.0版本
-paddlepaddle-gpu==0.14.0.post85     使用CUDA 8.0和cuDNN 5编译的0.14.0版本
-paddlepaddle-gpu==0.13.0            使用CUDA 9.0和cuDNN 7编译的0.13.0版本
-paddlepaddle-gpu==0.12.0            使用CUDA 8.0和cuDNN 5编译的0.12.0版本
-paddlepaddle-gpu==0.11.0.post87     使用CUDA 8.0和cuDNN 7编译的0.11.0版本
-paddlepaddle-gpu==0.11.0.post8      使用CUDA 8.0和cuDNN 5编译的0.11.0版本
-paddlepaddle-gpu==0.11.0            使用CUDA 7.5和cuDNN 5编译的0.11.0版本
-=================================   ========================================
-
-您可以在 `Release History <https://pypi.org/project/paddlepaddle-gpu/#history>`_
-中找到paddlepaddle-gpu的各个发行版本。
-
-如果需要获取并安装最新的PaddlePaddle开发分支，可以从我们的 `CI系统 <https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview>`_ 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。
-
-.. _FAQ:
-
-安装常见问题和解决方法
-======================
-
-- paddlepaddle*.whl is not a supported wheel on this platform.
-
-出现这个问题的主要原因是，没有找到和当前系统匹配的paddlepaddle安装包。
-请检查Python版本是否为2.7系列。另外最新的pip官方源中的安装包默认是manylinux1标准，
-需要使用最新的pip (>9.0.0) 才可以安装。
-
-可以使用下面的命令更新您的pip：
-
-  .. code-block:: bash
-
-      pip install --upgrade pip
-
-如果仍然存在问题，可以执行：
-
-    .. code-block:: bash
-
-        python -c "import pip; print(pip.pep425tags.get_supported())"
-
-获取当前系统支持的安装包格式，并检查和需安装的包是否匹配。pypi安装包
-可以在 `这里 <https://pypi.python.org/pypi/paddlepaddle/0.10.5>`_ 找到。
-
-如果系统支持的是 linux_x86_64 而安装包是 manylinux1_x86_64 ，需要升级pip版本到最新；
-如果系统支持 manylinux1_x86_64 而安装包（本地）是 linux_x86_64，
-可以重命名这个whl包为 manylinux1_x86_64 再安装。
-
-
-.. _install_windows:
-
-在Windows安装PaddlePaddle
-------------------------------
-Windows系统需要通过Docker来使用PaddleaPaddle。Docker是一个虚拟容器，使用Docker可以简化复杂的环境配置工作。
-
-我们提供了 `PaddlePaddle_Windows快速安装包 <http://paddle-windows.bj.bcebos.com/PaddlePaddle-windows.zip>`_，
-它能够帮助您安装Docker和PaddlePaddle。
-
-* 安装包支持的系统：Windows7，Windows8的所有版本，Windows10的专业版、企业版。
-
-* 如果您希望使用GPU提升训练速度，请使用Linux系统安装，Windows系统暂不支持。
-   
-.. _install_mac:
-
-在MacOS安装PaddlePaddle
---------
-
-对于MacOS系统，我们暂未提供pip安装方式，您可以使用 **源码编译** 的方式安装。
-
-.. _others:
-
-其他安装方式
--------------
-
-.. _source:
-源码编译（使用Docker镜像）
-==========
-
-.. _requirements:
-
-需要的软硬件
-"""""""""""""
-
-为了编译PaddlePaddle，我们需要
-
-1. 一台电脑，可以装的是 Linux, Windows 或者 MacOS 操作系统
-2. Docker
-
-不需要依赖其他任何软件了。即便是 Python 和 GCC 都不需要，因为我们会把所有编译工具都安装进一个 Docker 镜像里。
-
-.. _build_step:
-
-编译方法
-"""""""""""""
-
-PaddlePaddle需要使用Docker环境完成编译，这样可以免去单独安装编译依赖的步骤，可选的不同编译环境Docker镜像可以在 `这里 <https://hub.docker.com/r/paddlepaddle/paddle_manylinux_devel/tags/>`_ 找到。
-
-
-**I. 编译CPU-Only版本的PaddlePaddle，需要执行：**
-
-.. code-block:: bash
-
-   # 1. 获取源码
-   git clone https://github.com/PaddlePaddle/Paddle.git
-   cd Paddle
-   # 2. 执行如下命令下载最新版本的docker镜像
-   docker run --name paddle-test -v $PWD:/paddle --network=host -it docker.paddlepaddlehub.com/paddle:latest-dev /bin/bash
-   # 3. 进入docker内执行如下命令编译CPU-Only的二进制安装包
-   mkdir -p /paddle/build && cd /paddle/build
-   cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF
-   make -j$(nproc)
-
-**II. 编译GPU版本的PaddlePaddle，需要执行：**
-
-.. code-block:: bash
-
-  # 1. 获取源码 
-  git clone https://github.com/PaddlePaddle/Paddle.git 
-  cd Paddle
-  # 2. 安装nvidia-docker
-  apt-get install nvidia-docker
-  # 3. 执行如下命令下载支持GPU运行的docker容器
-  nvidia-docker run --name paddle-test-gpu -v $PWD:/paddle --network=host -it docker.paddlepaddlehub.com/paddle:latest-dev /bin/bash
-  # 4. 进入docker内执行如下命令编译GPU版本的PaddlePaddle
-  mkdir -p /paddle/build && cd /paddle/build
-  cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF
-  make -j$(nproc)
-
-**注意事项：**
-
-* 上述有关 :code:`docker` 的命令把当前目录（源码树根目录）映射为 container 里的 :code:`/paddle` 目录。
-* 进入 :code:`docker` 后执行 :code:`cmake` 命令，若是出现 :code:`patchelf not found, please install it.` 错误，则执行 :code:`apt-get install -y patchelf` 命令即可解决问题。
-* 若您在使用Docker编译PaddlePaddle遇到问题时， `这个issue <https://github.com/PaddlePaddle/Paddle/issues/12079>`_ 可能会对您有所帮助。
-
-
-.. _source:
-源码编译（不使用Docker镜像）
-==========
-
-如果您选择不使用Docker镜像，则需要在本机安装下面章节列出的 `附录：编译依赖`_ 之后才能开始编译的步骤。
-
-.. _build_step:
-
-编译方法
-"""""""""""""
-
-在本机上编译CPU-Only版本的PaddlePaddle，需要执行如下命令：
-
-.. code-block:: bash
-
-   # 1. 使用virtualenvwrapper创建python虚环境并将工作空间切换到虚环境 [可选]
-   mkvirtualenv paddle-venv
-   workon paddle-venv
-   # 2. 获取源码
-   git clone https://github.com/PaddlePaddle/Paddle.git
-   cd Paddle
-   # 3. 执行下面的命令编译CPU-Only的二进制
-   mkdir build && cd build
-   cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF
-   make -j4 # 根据机器配备CPU的核心数开启相应的多线程进行编译
-
-
-**注意事项：**
-
-* MacOS系统下因为默认安装了cblas库，所以编译时可能会遇到 :code:`use of undeclared identifier 'openblas_set_num_threads'` 错误。因此，在执行cmake命令时需要指定所使用openblas库的头文件路径，具体操作如下：
-
-  .. code-block:: bash
-
-    cd Paddle/build && rm -rf *
-    cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DOPENBLAS_INC_DIR=/usr/local/Cellar/openblas/[本机所安装的openblas版本号]/include/
-    make -j4 # 根据机器配备CPU的核心数开启相应的多线程进行编译
-* 若您在MacOS系统下从源码编译PaddlePaddle遇到问题时， `这个issue <https://github.com/PaddlePaddle/Paddle/issues/12078>`_ 可能会对您有所帮助。
-
-编译完成后会在build/python/dist目录下生成输出的whl包，可以选在在当前机器安装也可以拷贝到目标机器安装：
-
-.. code-block:: bash
-
-   pip install build/python/dist/*.whl
-
-如果机器中已经安装过PaddlePaddle，有两种方法：
-
-.. code-block:: bash
-
-   1. 先卸载之前的版本，再重新安装
-   pip uninstall paddlepaddle
-   pip install build/python/dist/*.whl
-
-   2. 直接升级到更新的版本
-   pip install build/python/dist/*.whl -U
-
-.. _run_test:
-
-执行单元测试
-"""""""""""""
-
-如果您期望在编译完成后立即执行所有的单元测试，可以按照下面的方法：
-
-设置 :code:`RUN_TEST=ON` 和 :code:`WITH_TESTING=ON` 就会在完成编译之后，立即执行单元测试。
-开启 :code:`WITH_GPU=ON` 可以指定同时执行GPU上的单元测试。
-
-.. code-block:: bash
-
-   docker run -it -v $PWD:/paddle -e "WITH_GPU=OFF" -e "WITH_TESTING=ON" -e "RUN_TEST=ON" docker.paddlepaddlehub.com/paddle:latest-dev bash -x /paddle/paddle/scripts/paddle_build.sh build
-
-如果期望执行其中一个单元测试，（比如 :code:`test_sum_op` ）：
-
-.. code-block:: bash
-
-   docker run -it -v $PWD:/paddle -e "WITH_GPU=OFF" -e "WITH_TESTING=ON" -e "RUN_TEST=OFF" docker.paddlepaddlehub.com/paddle:latest-dev bash -x /paddle/paddle/scripts/paddle_build.sh build
-   cd /paddle/build
-   ctest -R test_sum_op -V
-
-.. _faq_docker:
-
-常见问题
-"""""""""""""
-
-- 什么是 Docker?
-
-  如果您没有听说 Docker，可以把它想象为一个类似 virtualenv 的系统，但是虚拟的不仅仅是 Python 的运行环境。
-
-- Docker 还是虚拟机？
-
-  有人用虚拟机来类比 Docker。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。
-
-- 为什么用 Docker?
-
-  把工具和配置都安装在一个 Docker image 里可以标准化编译环境。这样如果遇到问题，其他人可以复现问题以便帮助。
-
-  另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。
-
-- 可以选择不用Docker吗？
-
-  当然可以。大家可以用把开发工具安装进入 Docker image 一样的方式，把这些工具安装到本机。这篇文档介绍基于 Docker 的开发流程，是因为这个流程比其他方法都更简便。
-
-- 学习 Docker 有多难？
-
-  理解 Docker 并不难，大概花十分钟看一下 `这篇文章 <https://zhuanlan.zhihu.com/p/19902938>`_。
-  这可以帮您省掉花一小时安装和配置各种开发工具，以及切换机器时需要新安装的辛苦。别忘了 PaddlePaddle 更新可能导致需要新的开发工具。更别提简化问题复现带来的好处了。
-
-- 可以用 IDE 吗？
-
-  当然可以，因为源码就在本机上。IDE 默认调用 make 之类的程序来编译源码，我们只需要配置 IDE 来调用 Docker 命令编译源码即可。
-
-  很多 PaddlePaddle 开发者使用 Emacs。他们在自己的 `~/.emacs` 配置文件里加两行
-
-  .. code-block:: bash
-
-    (global-set-key "\C-cc" 'compile)
-    (setq compile-command
-     "docker run --rm -it -v $(git rev-parse --show-toplevel):/paddle paddle:dev")
-
-  就可以按 `Ctrl-C` 和 `c` 键来启动编译了。
-
-- 可以并行编译吗？
-
-  是的。我们的 Docker image 运行一个 `Bash 脚本 <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/paddle/scripts/paddle_build.sh>`_。这个脚本调用 :code:`make -j$(nproc)` 来启动和 CPU 核一样多的进程来并行编译。
-
-- Docker 需要 sudo
-
-  如果用自己的电脑开发，自然也就有管理员权限（sudo）了。如果用公用的电脑开发，需要请管理员安装和配置好 Docker。此外，PaddlePaddle 项目在努力开始支持其他不需要 sudo 的集装箱技术，比如 rkt。
-
-- 在 Windows/MacOS 上编译很慢
-
-  Docker 在 Windows 和 MacOS 都可以运行。不过实际上是运行在一个 Linux 虚拟机上。可能需要注意给这个虚拟机多分配一些 CPU 和内存，以保证编译高效。具体做法请参考 `这个issue <https://github.com/PaddlePaddle/Paddle/issues/627>`_。
-
-- 磁盘不够
-
-  本文中的例子里， :code:`docker run` 命令里都用了 :code:`--rm` 参数，这样保证运行结束之后的 containers 不会保留在磁盘上。可以用 :code:`docker ps -a` 命令看到停止后但是没有删除的 containers。 :code:`docker build` 命令有时候会产生一些中间结果，是没有名字的 images，也会占用磁盘。可以参考 `这篇文章 <https://zaiste.net/posts/removing_docker_containers/>`_ 来清理这些内容。
-
-
-.. _compile_deps:
-
-附录：编译依赖
-"""""""""""""
-
-PaddlePaddle编译需要使用到下面的依赖（包含但不限于），其他的依赖软件，会自动在编译时下载。
-
-.. csv-table:: PaddlePaddle编译依赖
-   :header: "依赖", "版本", "说明"
-   :widths: 10, 15, 30
-
-   "CMake", "3.4", ""
-   "GCC", "4.8.2", "推荐使用CentOS的devtools2"
-   "Python", "2.7.x", "依赖libpython2.7.so"
-   "SWIG", ">=2.0", ""
-   "wget","",""
-   "openblas","",""
-   "pip", ">=9.0", ""
-   "numpy", "", ""
-   "protobuf","3.1.0",""
-   "wheel","",""
-   "Go", ">=1.8", "可选"
-
-
-.. _build_options:
-
-附录：编译选项
-"""""""""""""
-
-PaddlePaddle的编译选项，包括生成CPU/GPU二进制文件、链接何种BLAS库等。
-用户可在调用cmake的时候设置它们，详细的cmake使用方法可以参考
-`官方文档 <https://cmake.org/cmake-tutorial>`_ 。
-
-在cmake的命令行中，通过使用 ``-D`` 命令设置该类编译选项，例如：
-
-..  code-block:: bash
-
-    cmake .. -DWITH_GPU=OFF
-
-..  csv-table:: 编译选项说明
-    :header: "选项", "说明", "默认值"
-    :widths: 1, 7, 2
-
-    "WITH_GPU", "是否支持GPU", "ON"
-    "WITH_C_API", "是否仅编译CAPI", "OFF"
-    "WITH_DOUBLE", "是否使用双精度浮点数", "OFF"
-    "WITH_DSO", "是否运行时动态加载CUDA动态库，而非静态加载CUDA动态库。", "ON"
-    "WITH_AVX", "是否编译含有AVX指令集的PaddlePaddle二进制文件", "ON"
-    "WITH_PYTHON", "是否内嵌PYTHON解释器", "ON"
-    "WITH_STYLE_CHECK", "是否编译时进行代码风格检查", "ON"
-    "WITH_TESTING", "是否开启单元测试", "OFF"
-    "WITH_DOC", "是否编译中英文文档", "OFF"
-    "WITH_SWIG_PY", "是否编译PYTHON的SWIG接口，该接口可用于预测和定制化训练", "Auto"
-    "WITH_GOLANG", "是否编译go语言的可容错parameter server", "OFF"
-    "WITH_MKL", "是否使用MKL数学库，如果为否则是用OpenBLAS", "ON"
-
-BLAS
-+++++
-
-PaddlePaddle支持 `MKL <https://software.intel.com/en-us/intel-mkl>`_ 和
-`OpenBlAS <http://www.openblas.net/>`_ 两种BLAS库。默认使用MKL。如果使用MKL并且机器含有AVX2指令集，
-还会下载MKL-DNN数学库，详细参考 `这里 <https://github.com/PaddlePaddle/Paddle/tree/develop/doc/design/mkldnn#cmake>`_ 。
-
-如果关闭MKL，则会使用OpenBLAS作为BLAS库。
-
-CUDA/cuDNN
-+++++++++++
-
-PaddlePaddle在编译时/运行时会自动找到系统中安装的CUDA和cuDNN库进行编译和执行。
-使用参数 :code:`-DCUDA_ARCH_NAME=Auto` 可以指定开启自动检测SM架构，加速编译。
-
-PaddlePaddle可以使用cuDNN v5.1之后的任何一个版本来编译运行，但尽量请保持编译和运行使用的cuDNN是同一个版本。
-我们推荐使用最新版本的cuDNN。
-
-编译选项的设置
-++++++++++++++
-
-PaddePaddle通过编译时指定路径来实现引用各种BLAS/CUDA/cuDNN库。cmake编译时，首先在系统路径（ :code:`/usr/lib:/usr/local/lib` ）中搜索这几个库，同时也会读取相关路径变量来进行搜索。 通过使用 ``-D`` 命令可以设置，例如
-
-..  code-block:: bash
-
-    cmake .. -DWITH_GPU=ON -DWITH_TESTING=OFF -DCUDNN_ROOT=/opt/cudnnv5
-
-注意：这几个编译选项的设置，只在第一次cmake的时候有效。如果之后想要重新设置，推荐清理整个编译目录（ :code:`rm -rf` ）后，再指定。
-
-.. _install_docker:
-
-使用Docker安装运行
-==================
-
-使用Docker安装和运行PaddlePaddle可以无需考虑依赖环境。
-您可以在 `Docker官网 <https://docs.docker.com/get-started/>`_
-获得基本的Docker安装和使用方法。
-
-在了解Docker的基本使用方法之后，即可开始下面的步骤：
-
-.. _docker_pull:
-
-获取PaddlePaddle的Docker镜像
-""""""""""""""""""""""""""""
-
-执行下面的命令获取最新的PaddlePaddle Docker镜像，版本为cpu_avx_mkl：
-
-  .. code-block:: bash
-
-     docker pull paddlepaddle/paddle
-
-对于国内用户，我们提供了加速访问的镜像源：
-
-  .. code-block:: bash
-
-     docker pull docker.paddlepaddlehub.com/paddle
-
-下载GPU版本（cuda8.0_cudnn5_avx_mkl）的Docker镜像：
-
-  .. code-block:: bash
-
-     docker pull paddlepaddle/paddle:latest-gpu
-     docker pull docker.paddlepaddlehub.com/paddle:latest-gpu
-
-选择下载使用不同的BLAS库的Docker镜像：
-
-  .. code-block:: bash
-
-     # 默认是使用MKL的镜像
-     docker pull paddlepaddle/paddle
-     # 使用OpenBLAS的镜像
-     docker pull paddlepaddle/paddle:latest-openblas
-
-下载指定版本的Docker镜像，可以从 `DockerHub网站 <https://hub.docker.com/r/paddlepaddle/paddle/tags/>`_ 获取可选的tag，并执行下面的命令：
-
-  .. code-block:: bash
-
-     docker pull paddlepaddle/paddle:[tag]
-     # 比如：
-     docker pull docker.paddlepaddlehub.com/paddle:0.11.0-gpu
-
-.. _docker_run:
-
-在Docker中执行PaddlePaddle训练程序
-"""""""""""""""""""""""""""""""""""
-
-假设您已经在当前目录（比如在/home/work）编写了一个PaddlePaddle的程序 :code:`train.py` （可以参考
-`PaddlePaddleBook <http://www.paddlepaddle.org/docs/develop/book/01.fit_a_line/index.cn.html>`_
-编写），就可以使用下面的命令开始执行训练：
-
-  .. code-block:: bash
-
-     cd /home/work
-     docker run -it -v $PWD:/work paddlepaddle/paddle /work/train.py
-
-上述命令中， :code:`-it` 参数说明容器已交互式运行； :code:`-v $PWD:/work`
-指定将当前路径（Linux中$PWD变量会展开为当前路径的绝对路径）挂载到容器内部的 :code:`/work`
-目录； :code:`paddlepaddle/paddle` 指定需要使用的容器； 最后 :code:`/work/train.py`
-为容器内执行的命令，即运行训练程序。
-
-当然，您也可以进入到Docker容器中，以交互式的方式执行或调试您的代码：
-
-  .. code-block:: bash
-     docker run -it -v $PWD:/work paddlepaddle/paddle /bin/bash
-     cd /work
-     python train.py
-
-**注：PaddlePaddle Docker镜像为了减小体积，默认没有安装vim，您可以在容器中执行** :code:`apt-get install -y vim` **安装后，在容器中编辑代码。**
-
-.. _docker_run_book:
-
-使用Docker启动PaddlePaddle Book教程
-""""""""""""""""""""""""""""""""""""
-
-使用Docker可以快速在本地启动一个包含了PaddlePaddle官方Book教程的Jupyter Notebook，可以通过网页浏览。
-PaddlePaddle Book是为用户和开发者制作的一个交互式的Jupyter Notebook。
-如果您想要更深入了解deep learning，PaddlePaddle Book一定是您最好的选择。
-大家可以通过它阅读教程，或者制作和分享带有代码、公式、图表、文字的交互式文档。
-
-我们提供可以直接运行PaddlePaddle Book的Docker镜像，直接运行：
-
-  .. code-block:: bash
-
-     docker run -p 8888:8888 paddlepaddle/book
-
-国内用户可以使用下面的镜像源来加速访问：
-
-  .. code-block: bash
-
-    docker run -p 8888:8888 docker.paddlepaddlehub.com/book
-
-然后在浏览器中输入以下网址：
-
-  .. code-block:: text
-
-     http://localhost:8888/
-
-就这么简单，享受您的旅程！
-
-.. _docker_run_gpu:
-
-使用Docker执行GPU训练
-""""""""""""""""""""""""""""
-
-为了保证GPU驱动能够在镜像里面正常运行，我们推荐使用
-`nvidia-docker <https://github.com/NVIDIA/nvidia-docker>`_ 来运行镜像。
-请不要忘记提前在物理机上安装GPU最新驱动。
-
-  .. code-block:: bash
-
-     nvidia-docker run -it -v $PWD:/work paddlepaddle/paddle:latest-gpu /bin/bash
-
-**注: 如果没有安装nvidia-docker，可以尝试以下的方法，将CUDA库和Linux设备挂载到Docker容器内：**
-
-  .. code-block:: bash
-
-     export CUDA_SO="$(\ls /usr/lib64/libcuda* | xargs -I{} echo '-v {}:{}') $(\ls /usr/lib64/libnvidia* | xargs -I{} echo '-v {}:{}')"
-     export DEVICES=$(\ls /dev/nvidia* | xargs -I{} echo '--device {}:{}')
-     docker run ${CUDA_SO} ${DEVICES} -it paddlepaddle/paddle:latest-gpu
-
-**关于AVX：**
-
-AVX是一种CPU指令集，可以加速PaddlePaddle的计算。最新的PaddlePaddle Docker镜像默认
-是开启AVX编译的，所以，如果您的电脑不支持AVX，需要单独
-`编译 <./build_from_source_cn.html>`_ PaddlePaddle为no-avx版本。
-
-以下指令能检查Linux电脑是否支持AVX：
-
-   .. code-block:: bash
-
-      if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
-
-如果输出是No，就需要选择使用no-AVX的镜像
diff --git a/doc/fluid/new_docs/beginners_guide/install/paddleci.png b/doc/fluid/new_docs/beginners_guide/install/paddleci.png
deleted file mode 100644
index 16087ce059aa3c07ce8c927d983eb86351915825..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 40242
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
TDaF2yYT()L>EluB9!dQV$m`bb

-- 
GitLab