Skip to content

P
Paddle

PaddlePaddle / Paddle
大约 2 年 前同步成功

通知 2325
Star 20933
Fork 5424
P
Paddle
“8f156b5e2e222167172f1f2dae32ead2adcf9001”上不存在“doc/mobile/cross_compiling_for_raspberry_en.html”
提交 da72b34c 编写于 作者: T Travis CI
浏览文件
操作

Deploy to GitHub Pages: c99bef61

上级 a337e5b4
隐藏空白更改
内联 并排
Showing with 211 addition and 219 deletion
develop/doc/_sources/getstarted/build_and_install/docker_install_en.rst.txt
浏览文件 @ da72b34c
......@@ -53,12 +53,20 @@ Docker is simple as long as we understand a few basic concepts:
Usage of CPU-only and GPU Images
----------------------------------
For each version of PaddlePaddle, we release two types of Docker images:
development image and production image. Production image includes
CPU-only version and a CUDA GPU version and their no-AVX versions. We
put the docker images on `dockerhub.com
We package PaddlePaddle's compile environment into a Docker image,
called the develop image, it contains all compiling tools that
PaddlePaddle needs. We package compiled PaddlePaddle program into a
Docker image as well, called the production image, it contains all
runtime environment that running PaddlePaddle needs. For each version
of PaddlePaddle, we release both of them. Production image includes
CPU-only version and a CUDA GPU version and their no-AVX versions.
We put the docker images on `dockerhub.com
<https://hub.docker.com/r/paddledev/paddle/>`_. You can find the
latest versions under "tags" tab at dockerhub.com
latest versions under "tags" tab at dockerhub.com. If you are in
China, you can use our Docker image registry mirror to speed up the
download process. To use it, please replace all paddlepaddle/paddle in
the commands to docker.paddlepaddle.org/paddle.
1. Production images, this image might have multiple variants:
......@@ -179,59 +187,40 @@ Develop PaddlePaddle or Train Model Using C++ API
We will be using PaddlePaddle development image since it contains all
compiling tools and dependencies.
Let's clone PaddlePaddle repo first:
1. Build PaddlePaddle develop image
.. code-block:: bash
git clone https://github.com/PaddlePaddle/Paddle.git && cd Paddle
Mount both workspace folder and paddle code folder into docker
container, so we can access them inside docker container. There are
two ways of using PaddlePaddle development docker image:
- run interactive bash directly
Use following command to build PaddlePaddle develop image:
.. code-block:: bash
# use nvidia-docker instead of docker if you need to use GPU
docker run -it -v ~/workspace:/workspace -v $(pwd):/paddle paddlepaddle/paddle:0.10.0rc2-dev /bin/bash
# now we are inside docker container
.. code-block:: bash
- or, we can run it as a daemon container
git clone https://github.com/PaddlePaddle/Paddle.git && cd Paddle
docker build -t paddle:dev .
.. code-block:: bash
2. Build PaddlePaddle production image
# use nvidia-docker instead of docker if you need to use GPU
docker run -d -p 2202:22 -p 8888:8888 -v ~/workspace:/workspace -v $(pwd):/paddle paddlepaddle/paddle:0.10.0rc2-dev /usr/sbin/sshd -D
There are two steps for building production image, the first step is to run:
and SSH to this container using password :code:`root`:
.. code-block:: bash
.. code-block:: bash
ssh -p 2202 root@localhost
docker run -v $(pwd):/paddle -e "WITH_GPU=OFF" -e "WITH_AVX=OFF" -e "WITH_TEST=ON" paddle:dev
An advantage is that we can run the PaddlePaddle container on a
remote server and SSH to it from a laptop.
The above command will compile PaddlePaddle and create a Dockerfile for building production image. All the generated files are in the build directory. "WITH_GPU" controls if the generated production image supports GPU. "WITH_AVX" controls if the generated production image supports AVX. "WITH_TEST" controls if the unit test will be generated.
When developing PaddlePaddle, you can edit PaddlePaddle source code
from outside of docker container using your favoriate editor. To
compile PaddlePaddle, run inside container:
The second step is to run:
.. code-block:: bash
.. code-block:: bash
WITH_GPU=OFF WITH_AVX=ON WITH_TEST=ON bash /paddle/paddle/scripts/docker/build.sh
docker build -t paddle:prod -f build/Dockerfile .
This builds everything about Paddle in :code:`/paddle/build`. And we
can run unit tests there:
The above command will generate the production image by copying the compiled PaddlePaddle program into the image.
.. code-block:: bash
3. Run unit test
cd /paddle/build
ctest
Following command will run unit test:
When training model using C++ API, we can edit paddle program in
~/workspace outside of docker. And build from /workspace inside of
docker.
.. code-block:: bash
docker run -it -v $(pwd):/paddle paddle:dev bash -c "cd /paddle/build && ctest"
PaddlePaddle Book
------------------
......
develop/doc/getstarted/build_and_install/docker_install_en.html
浏览文件 @ da72b34c
......@@ -260,11 +260,18 @@ command <code class="code docutils literal"><span class="pre">ls</span> <span cl
</div>
<div class="section" id="usage-of-cpu-only-and-gpu-images">
<h2>Usage of CPU-only and GPU Images<a class="headerlink" href="#usage-of-cpu-only-and-gpu-images" title="Permalink to this headline"></a></h2>
<p>For each version of PaddlePaddle, we release two types of Docker images:
development image and production image. Production image includes
CPU-only version and a CUDA GPU version and their no-AVX versions. We
put the docker images on <a class="reference external" href="https://hub.docker.com/r/paddledev/paddle/">dockerhub.com</a>. You can find the
latest versions under &#8220;tags&#8221; tab at dockerhub.com</p>
<p>We package PaddlePaddle&#8217;s compile environment into a Docker image,
called the develop image, it contains all compiling tools that
PaddlePaddle needs. We package compiled PaddlePaddle program into a
Docker image as well, called the production image, it contains all
runtime environment that running PaddlePaddle needs. For each version
of PaddlePaddle, we release both of them. Production image includes
CPU-only version and a CUDA GPU version and their no-AVX versions.</p>
<p>We put the docker images on <a class="reference external" href="https://hub.docker.com/r/paddledev/paddle/">dockerhub.com</a>. You can find the
latest versions under &#8220;tags&#8221; tab at dockerhub.com. If you are in
China, you can use our Docker image registry mirror to speed up the
download process. To use it, please replace all paddlepaddle/paddle in
the commands to docker.paddlepaddle.org/paddle.</p>
<ol class="arabic">
<li><p class="first">Production images, this image might have multiple variants:</p>
<ul class="simple">
......@@ -359,49 +366,33 @@ python example.py
<h2>Develop PaddlePaddle or Train Model Using C++ API<a class="headerlink" href="#develop-paddlepaddle-or-train-model-using-c-api" title="Permalink to this headline"></a></h2>
<p>We will be using PaddlePaddle development image since it contains all
compiling tools and dependencies.</p>
<p>Let&#8217;s clone PaddlePaddle repo first:</p>
<ol class="arabic">
<li><p class="first">Build PaddlePaddle develop image</p>
<p>Use following command to build PaddlePaddle develop image:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>git clone https://github.com/PaddlePaddle/Paddle.git <span class="o">&amp;&amp;</span> <span class="nb">cd</span> Paddle
</pre></div>
</div>
<p>Mount both workspace folder and paddle code folder into docker
container, so we can access them inside docker container. There are
two ways of using PaddlePaddle development docker image:</p>
<ul>
<li><p class="first">run interactive bash directly</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="c1"># use nvidia-docker instead of docker if you need to use GPU</span>
docker run -it -v ~/workspace:/workspace -v <span class="k">$(</span><span class="nb">pwd</span><span class="k">)</span>:/paddle paddlepaddle/paddle:0.10.0rc2-dev /bin/bash
<span class="c1"># now we are inside docker container</span>
docker build -t paddle:dev .
</pre></div>
</div>
</li>
<li><p class="first">or, we can run it as a daemon container</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="c1"># use nvidia-docker instead of docker if you need to use GPU</span>
docker run -d -p <span class="m">2202</span>:22 -p <span class="m">8888</span>:8888 -v ~/workspace:/workspace -v <span class="k">$(</span><span class="nb">pwd</span><span class="k">)</span>:/paddle paddlepaddle/paddle:0.10.0rc2-dev /usr/sbin/sshd -D
<li><p class="first">Build PaddlePaddle production image</p>
<p>There are two steps for building production image, the first step is to run:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -v <span class="k">$(</span><span class="nb">pwd</span><span class="k">)</span>:/paddle -e <span class="s2">&quot;WITH_GPU=OFF&quot;</span> -e <span class="s2">&quot;WITH_AVX=OFF&quot;</span> -e <span class="s2">&quot;WITH_TEST=ON&quot;</span> paddle:dev
</pre></div>
</div>
<p>and SSH to this container using password <code class="code docutils literal"><span class="pre">root</span></code>:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>ssh -p <span class="m">2202</span> root@localhost
<p>The above command will compile PaddlePaddle and create a Dockerfile for building production image. All the generated files are in the build directory. &#8220;WITH_GPU&#8221; controls if the generated production image supports GPU. &#8220;WITH_AVX&#8221; controls if the generated production image supports AVX. &#8220;WITH_TEST&#8221; controls if the unit test will be generated.</p>
<p>The second step is to run:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker build -t paddle:prod -f build/Dockerfile .
</pre></div>
</div>
<p>An advantage is that we can run the PaddlePaddle container on a
remote server and SSH to it from a laptop.</p>
<p>The above command will generate the production image by copying the compiled PaddlePaddle program into the image.</p>
</li>
</ul>
<p>When developing PaddlePaddle, you can edit PaddlePaddle source code
from outside of docker container using your favoriate editor. To
compile PaddlePaddle, run inside container:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="nv">WITH_GPU</span><span class="o">=</span>OFF <span class="nv">WITH_AVX</span><span class="o">=</span>ON <span class="nv">WITH_TEST</span><span class="o">=</span>ON bash /paddle/paddle/scripts/docker/build.sh
</pre></div>
</div>
<p>This builds everything about Paddle in <code class="code docutils literal"><span class="pre">/paddle/build</span></code>. And we
can run unit tests there:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="nb">cd</span> /paddle/build
ctest
<li><p class="first">Run unit test</p>
<p>Following command will run unit test:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it -v <span class="k">$(</span><span class="nb">pwd</span><span class="k">)</span>:/paddle paddle:dev bash -c <span class="s2">&quot;cd /paddle/build &amp;&amp; ctest&quot;</span>
</pre></div>
</div>
<p>When training model using C++ API, we can edit paddle program in
~/workspace outside of docker. And build from /workspace inside of
docker.</p>
</li>
</ol>
</div>
<div class="section" id="paddlepaddle-book">
<h2>PaddlePaddle Book<a class="headerlink" href="#paddlepaddle-book" title="Permalink to this headline"></a></h2>
......
develop/doc/searchindex.js
浏览文件 @ da72b34c
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
develop/doc_cn/_sources/getstarted/build_and_install/docker_install_cn.rst.txt
浏览文件 @ da72b34c
......@@ -4,93 +4,112 @@ PaddlePaddle的Docker容器使用方式
PaddlePaddle目前唯一官方支持的运行的方式是Docker容器。因为Docker能在所有主要操作系统（包括Linux，Mac OS X和Windows）上运行。 请注意，您需要更改 `Dockers设置 <https://github.com/PaddlePaddle/Paddle/issues/627>`_ 才能充分利用Mac OS X和Windows上的硬件资源。
PaddlePaddle发布的docker镜像使用说明
PaddlePaddle发布的Docker镜像使用说明
------------------------------
对于每一个PaddlePaddle版本，我们都会发布两种Docker镜像：开发镜像、运行镜像。运行镜像包括纯CPU版本和GPU版本以及其对应的非AVX版本。
我们会在 `dockerhub.com <https://hub.docker.com/r/paddledev/paddle/>`_ 提供最新的docker镜像，可以在"tags"标签下找到最新的Paddle镜像版本。
我们把PaddlePaddle的编译环境打包成一个镜像，称为开发镜像，里面涵盖了
PaddlePaddle需要的所有编译工具。把编译出来的PaddlePaddle也打包成一个镜
像，称为生产镜像，里面涵盖了PaddlePaddle运行所需的所有环境。每次
PaddlePaddle发布新版本的时候都会发布对应版本的生产镜像以及开发镜像。运
行镜像包括纯CPU版本和GPU版本以及其对应的非AVX版本。我们会在
`dockerhub.com <https://hub.docker.com/r/paddledev/paddle/>`_ 提供最新
的Docker镜像，可以在"tags"标签下找到最新的Paddle镜像版本。为了方便在国
内的开发者下载Docker镜像，我们提供了国内的镜像服务器供大家使用。如果您
在国内，请把文档里命令中的paddlepaddle/paddle替换成
docker.paddlepaddle.org/paddle。
1. 开发镜像：:code:`paddlepaddle/paddle:<version>-dev`
这个镜像包含了Paddle相关的开发工具以及编译和运行环境。用户可以使用开发镜像代替配置本地环境，完成开发，编译，发布，
文档编写等工作。由于不同的Paddle的版本可能需要不同的依赖和工具，所以如果需要自行配置开发环境需要考虑版本的因素。
开发镜像包含了以下工具：
- gcc/clang
- nvcc
- Python
- sphinx
- woboq
- sshd
很多开发者会使用远程的安装有GPU的服务器工作，用户可以使用ssh登录到这台服务器上并执行 :code:`docker exec`进入开发镜像并开始工作，
也可以在开发镜像中启动一个SSHD服务，方便开发者直接登录到镜像中进行开发:
这个镜像包含了Paddle相关的开发工具以及编译和运行环境。用户可以使用开发镜像代替配置本地环境，完成开发，编译，发布，
文档编写等工作。由于不同的Paddle的版本可能需要不同的依赖和工具，所以如果需要自行配置开发环境需要考虑版本的因素。
开发镜像包含了以下工具：
- gcc/clang
- nvcc
- Python
- sphinx
- woboq
- sshd
很多开发者会使用远程的安装有GPU的服务器工作，用户可以使用ssh登录到这台服务器上并执行 :code:`docker exec`进入开发镜像并开始工作，
也可以在开发镜像中启动一个SSHD服务，方便开发者直接登录到镜像中进行开发:
以交互容器方式运行开发镜像：
.. code-block:: bash
docker run -it --rm paddlepaddle/paddle:<version>-dev /bin/bash
或者，可以以后台进程方式运行容器：
.. code-block:: bash
docker run -d -p 2202:22 -p 8888:8888 paddledev/paddle:<version>-dev
以交互容器方式运行开发镜像：
然后用密码 :code:`root` SSH进入容器：
.. code-block:: bash
.. code-block:: bash
docker run -it --rm paddledev/paddle:<version>-dev /bin/bash
ssh -p 2202 root@localhost
或者，可以以后台进程方式运行容器：
SSH方式的一个优点是我们可以从多个终端进入容器。比如，一个终端运行vi，另一个终端运行Python。另一个好处是我们可以把PaddlePaddle容器运行在远程服务器上，并在笔记本上通过SSH与其连接。
.. code-block:: bash
2. 生产镜像：根据CPU、GPU和非AVX区分了如下4个镜像：
docker run -d -p 2202:22 -p 8888:8888 paddledev/paddle:<version>-dev
- GPU/AVX：:code:`paddlepaddle/paddle:<version>-gpu`
- GPU/no-AVX：:code:`paddlepaddle/paddle:<version>-gpu-noavx`
- CPU/AVX：:code:`paddlepaddle/paddle:<version>`
- CPU/no-AVX：:code:`paddlepaddle/paddle:<version>-noavx`
然后用密码 :code:`root` SSH进入容器：
纯CPU镜像以及GPU镜像都会用到AVX指令集，但是2008年之前生产的旧电脑不支持AVX。以下指令能检查Linux电脑是否支持AVX：
.. code-block:: bash
.. code-block:: bash
ssh -p 2202 root@localhost
if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
SSH方式的一个优点是我们可以从多个终端进入容器。比如，一个终端运行vi，另一个终端运行Python。另一个好处是我们可以把PaddlePaddle容器运行在远程服务器上，并在笔记本上通过SSH与其连接。
如果输出是No，就需要选择使用no-AVX的镜像
2. 运行镜像：根据CPU、GPU和非AVX区分了如下4个镜像：
- GPU/AVX：:code:`paddlepaddle/paddle:<version>-gpu`
- GPU/no-AVX：:code:`paddlepaddle/paddle:<version>-gpu-noavx`
- CPU/AVX：:code:`paddlepaddle/paddle:<version>`
- CPU/no-AVX：:code:`paddlepaddle/paddle:<version>-noavx`
以上方法在GPU镜像里也能用，只是请不要忘记提前在物理机上安装GPU最新驱动。
为了保证GPU驱动能够在镜像里面正常运行，我们推荐使用[nvidia-docker](https://github.com/NVIDIA/nvidia-docker)来运行镜像。
纯CPU镜像以及GPU镜像都会用到AVX指令集，但是2008年之前生产的旧电脑不支持AVX。以下指令能检查Linux电脑是否支持AVX：
.. code-block:: bash
.. code-block:: bash
nvidia-docker run -it --rm paddledev/paddle:0.10.0rc1-gpu /bin/bash
if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
注意: 如果使用nvidia-docker存在问题，你也许可以尝试更老的方法，具体如下，但是我们并不推荐这种方法。：
如果输出是No，就需要选择使用no-AVX的镜像
.. code-block:: bash
以上方法在GPU镜像里也能用，只是请不要忘记提前在物理机上安装GPU最新驱动。
为了保证GPU驱动能够在镜像里面正常运行，我们推荐使用[nvidia-docker](https://github.com/NVIDIA/nvidia-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 paddledev/paddle:<version>-gpu
.. code-block:: bash
3. 运行以及发布您的AI程序
nvidia-docker run -it --rm paddledev/paddle:0.10.0rc1-gpu /bin/bash
假设您已经完成了一个AI训练的python程序 :code:`a.py`，这个程序是您在开发机上使用开发镜像完成开发。此时您可以运行这个命令在开发机上进行测试运行：
注意: 如果使用nvidia-docker存在问题，你也许可以尝试更老的方法，具体如下，但是我们并不推荐这种方法。：
.. code-block:: bash
.. code-block:: bash
docker run -it -v $PWD:/work paddle /work/a.py
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 paddledev/paddle:<version>-gpu
如果要使用GPU，请运行：
3. 使用运行镜像发布你的AI程序
假设您已经完成了一个AI训练的python程序 :code:`a.py`，这个程序是您在开发机上使用开发镜像完成开发。此时您可以运行这个命令在开发机上进行测试运行：
.. code-block:: bash
.. code-block:: bash
nvidia-docker run -it -v $PWD:/work paddle /work/a.py
docker run -it -v $PWD:/work paddle /work/a.py
这里`a.py`包含的所有依赖假设都可以在Paddle的运行容器中。如果需要包含更多的依赖、或者需要发布您的应用的镜像，可以编写`Dockerfile`使用`FROM paddledev/paddle:<version>`
创建和发布自己的AI程序镜像。
这里`a.py`包含的所有依赖假设都可以在Paddle的运行容器中。如果需要包含更多的依赖、或者需要发布您的应用的镜像，可以编写`Dockerfile`使用`FROM paddledev/paddle:<version>`
创建和发布自己的AI程序镜像。
运行PaddlePaddle书籍
运行PaddlePaddle Book
---------------------
Jupyter Notebook是一个开源的web程序，大家可以通过它制作和分享带有代码、公式、图表、文字的交互式文档。用户可以通过网页浏览文档。
PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nodebook。
如果您想要更深入了解deep learning，PaddlePaddle书籍一定是您最好的选择。
PaddlePaddle Book是为用户和开发者制作的一个交互式的Jupyter Nodebook。
如果您想要更深入了解deep learning，PaddlePaddle Book一定是您最好的选择。
我们提供可以直接运行PaddlePaddle书籍的docker镜像，直接运行：
我们提供可以直接运行PaddlePaddle Book的Docker镜像，直接运行：
.. code-block:: bash
......@@ -109,53 +128,44 @@ PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nod
开发人员可以在Docker开发镜像中开发PaddlePaddle。这样开发人员可以以一致的方式在不同的平台上工作 - Linux，Mac OS X和Windows。
1. 构建开发镜像
1. 制作PaddlePaddle开发镜像
.. code-block:: bash
PaddlePaddle每次发布新版本都会发布对应的开发镜像供开发者直接使用。这里介绍如生成造这个开发镜像。
生成Docker镜像的方式有两个，一个是直接把一个容器转换成镜像，另一个是创建Dockerfile并运行docker build指令按照Dockerfile生成镜像。第一个方法的好处是简单快捷，适合自己实验，可以快速迭代。第二个方法的好处是Dockerfile可以把整个生成流程描述很清楚，其他人很容易看懂镜像生成过程，持续集成系统也可以简单地复现这个过程。我们采用第二个方法。Dockerfile位于PaddlePaddle repo的根目录。生成生产镜像只需要运行：
git clone --recursive https://github.com/PaddlePaddle/Paddle
.. code-block:: bash
git clone https://github.com/PaddlePaddle/Paddle.git
cd Paddle
docker build -t paddle:dev .
docker build这个命令的-t指定了生成的镜像的名字，这里我们用paddle:dev。到此，PaddlePaddle开发镜像就被构建完毕了。
请注意，默认情况下，:code:`docker build` 不会将源码导入到镜像中并编译它。如果我们想这样做，需要构建完开发镜像，然后执行：
.. code-block:: bash
docker run -v $PWD:/paddle -e "WITH_GPU=OFF" -e "WITH_AVX=ON" -e "TEST=OFF" paddle:dev
2. 运行开发环境
2. 制作PaddlePaddle生产镜像
当我们编译好了 :code:`paddle:dev`， 我们可以在docker容器里做开发，源代码可以通过挂载本地文件来被载入Docker的开发环境里面：
生产镜像的生成分为两步，第一步是运行：
.. code-block:: bash
docker run -v $(pwd):/paddle -e "WITH_GPU=OFF" -e "WITH_AVX=OFF" -e "WITH_TEST=ON" paddle:dev
docker run -d -p 2202:22 -v $PWD:/paddle paddle:dev sshd
以上命令会编译PaddlePaddle，生成运行程序，以及生成创建生产镜像的Dockerfile。所有生成的的文件都在build目录下。“WITH_GPU”控制生成的生产镜像是否支持GPU，“WITH_AVX”控制生成的生产镜像是否支持AVX，”WITH_TEST“控制是否生成单元测试。
以上代码会启动一个带有PaddlePaddle开发环境的docker容器，源代码会被挂载到 :code:`/paddle` 。
以上的 :code:`docker run` 命令其实会启动一个在2202端口监听的SSHD服务器。这样，我们就能SSH进入我们的开发容器了：
第二步是运行：
.. code-block:: bash
docker build -t paddle:prod -f build/Dockerfile .
ssh root@localhost -p 2202
以上命令会按照生成的Dockerfile把生成的程序拷贝到生产镜像中并做相应的配置，最终生成名为paddle:prod的生产镜像。
3. 在Docker开发环境中编译与安装PaddlPaddle代码
3. 运行单元测试
当在容器里面的时候，可以用脚本 :code:`paddle/scripts/docker/build.sh` 来编译、安装与测试PaddlePaddle：
运行以下指令：
.. code-block:: bash
/paddle/paddle/scripts/docker/build.sh
以上指令会在 :code:`/paddle/build` 中编译PaddlePaddle。通过以下指令可以运行单元测试：
.. code-block:: bash
cd /paddle/build
ctest
docker run -it -v $(pwd):/paddle paddle:dev bash -c "cd /paddle/build && ctest"
文档
----
......
develop/doc_cn/getstarted/build_and_install/docker_install_cn.html
浏览文件 @ da72b34c
......@@ -180,8 +180,8 @@
<nav class="local-toc"><ul>
<li><a class="reference internal" href="#">PaddlePaddle的Docker容器使用方式</a><ul>
<li><a class="reference internal" href="#id1">PaddlePaddle发布的docker镜像使用说明</a></li>
<li><a class="reference internal" href="#paddlepaddle">运行PaddlePaddle书籍</a></li>
<li><a class="reference internal" href="#id1">PaddlePaddle发布的Docker镜像使用说明</a></li>
<li><a class="reference internal" href="#paddlepaddle-book">运行PaddlePaddle Book</a></li>
<li><a class="reference internal" href="#dockerpaddlepaddle">通过Docker容器开发PaddlePaddle</a></li>
<li><a class="reference internal" href="#id4">文档</a></li>
</ul>
......@@ -221,24 +221,34 @@
<h1>PaddlePaddle的Docker容器使用方式<a class="headerlink" href="#paddlepaddledocker" title="永久链接至标题"></a></h1>
<p>PaddlePaddle目前唯一官方支持的运行的方式是Docker容器。因为Docker能在所有主要操作系统（包括Linux，Mac OS X和Windows）上运行。 请注意，您需要更改 <a class="reference external" href="https://github.com/PaddlePaddle/Paddle/issues/627">Dockers设置</a> 才能充分利用Mac OS X和Windows上的硬件资源。</p>
<div class="section" id="id1">
<h2>PaddlePaddle发布的docker镜像使用说明<a class="headerlink" href="#id1" title="永久链接至标题"></a></h2>
<p>对于每一个PaddlePaddle版本，我们都会发布两种Docker镜像：开发镜像、运行镜像。运行镜像包括纯CPU版本和GPU版本以及其对应的非AVX版本。
我们会在 <a class="reference external" href="https://hub.docker.com/r/paddledev/paddle/">dockerhub.com</a> 提供最新的docker镜像，可以在&#8221;tags&#8221;标签下找到最新的Paddle镜像版本。
1. 开发镜像：<code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;-dev</span></code></p>
<blockquote>
<div><p>这个镜像包含了Paddle相关的开发工具以及编译和运行环境。用户可以使用开发镜像代替配置本地环境，完成开发，编译，发布，
<h2>PaddlePaddle发布的Docker镜像使用说明<a class="headerlink" href="#id1" title="永久链接至标题"></a></h2>
<p>我们把PaddlePaddle的编译环境打包成一个镜像，称为开发镜像，里面涵盖了
PaddlePaddle需要的所有编译工具。把编译出来的PaddlePaddle也打包成一个镜
像，称为生产镜像，里面涵盖了PaddlePaddle运行所需的所有环境。每次
PaddlePaddle发布新版本的时候都会发布对应版本的生产镜像以及开发镜像。运
行镜像包括纯CPU版本和GPU版本以及其对应的非AVX版本。我们会在
<a class="reference external" href="https://hub.docker.com/r/paddledev/paddle/">dockerhub.com</a> 提供最新
的Docker镜像，可以在&#8221;tags&#8221;标签下找到最新的Paddle镜像版本。为了方便在国
内的开发者下载Docker镜像，我们提供了国内的镜像服务器供大家使用。如果您
在国内，请把文档里命令中的paddlepaddle/paddle替换成
docker.paddlepaddle.org/paddle。</p>
<ol class="arabic">
<li><p class="first">开发镜像：<code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;-dev</span></code></p>
<p>这个镜像包含了Paddle相关的开发工具以及编译和运行环境。用户可以使用开发镜像代替配置本地环境，完成开发，编译，发布，
文档编写等工作。由于不同的Paddle的版本可能需要不同的依赖和工具，所以如果需要自行配置开发环境需要考虑版本的因素。
开发镜像包含了以下工具：
- gcc/clang
- nvcc
- Python
- sphinx
- woboq
- sshd
很多开发者会使用远程的安装有GPU的服务器工作，用户可以使用ssh登录到这台服务器上并执行 :code:<a href="#id2"><span class="problematic" id="id3">`</span></a>docker exec`进入开发镜像并开始工作，
开发镜像包含了以下工具：</p>
<ul class="simple">
<li>gcc/clang</li>
<li>nvcc</li>
<li>Python</li>
<li>sphinx</li>
<li>woboq</li>
<li>sshd</li>
</ul>
<p>很多开发者会使用远程的安装有GPU的服务器工作，用户可以使用ssh登录到这台服务器上并执行 :code:<a href="#id2"><span class="problematic" id="id3">`</span></a>docker exec`进入开发镜像并开始工作，
也可以在开发镜像中启动一个SSHD服务，方便开发者直接登录到镜像中进行开发:</p>
<p>以交互容器方式运行开发镜像：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it --rm paddledev/paddle:&lt;version&gt;-dev /bin/bash
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it --rm paddlepaddle/paddle:&lt;version&gt;-dev /bin/bash
</pre></div>
</div>
<p>或者，可以以后台进程方式运行容器：</p>
......@@ -250,11 +260,9 @@
</pre></div>
</div>
<p>SSH方式的一个优点是我们可以从多个终端进入容器。比如，一个终端运行vi，另一个终端运行Python。另一个好处是我们可以把PaddlePaddle容器运行在远程服务器上，并在笔记本上通过SSH与其连接。</p>
</div></blockquote>
<ol class="arabic" start="2">
<li><dl class="first docutils">
<dt>运行镜像：根据CPU、GPU和非AVX区分了如下4个镜像：</dt>
<dd><ul class="first simple">
</li>
<li><p class="first">生产镜像：根据CPU、GPU和非AVX区分了如下4个镜像：</p>
<ul class="simple">
<li>GPU/AVX：<code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;-gpu</span></code></li>
<li>GPU/no-AVX：<code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;-gpu-noavx</span></code></li>
<li>CPU/AVX：<code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;</span></code></li>
......@@ -271,33 +279,32 @@
</pre></div>
</div>
<p>注意: 如果使用nvidia-docker存在问题，你也许可以尝试更老的方法，具体如下，但是我们并不推荐这种方法。：</p>
<div class="last highlight-bash"><div class="highlight"><pre><span></span><span class="nb">export</span> <span class="nv">CUDA_SO</span><span class="o">=</span><span class="s2">&quot;</span><span class="k">$(</span><span class="se">\l</span>s /usr/lib64/libcuda* <span class="p">|</span> xargs -I<span class="o">{}</span> <span class="nb">echo</span> <span class="s1">&#39;-v {}:{}&#39;</span><span class="k">)</span><span class="s2"> </span><span class="k">$(</span><span class="se">\l</span>s /usr/lib64/libnvidia* <span class="p">|</span> xargs -I<span class="o">{}</span> <span class="nb">echo</span> <span class="s1">&#39;-v {}:{}&#39;</span><span class="k">)</span><span class="s2">&quot;</span>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="nb">export</span> <span class="nv">CUDA_SO</span><span class="o">=</span><span class="s2">&quot;</span><span class="k">$(</span><span class="se">\l</span>s /usr/lib64/libcuda* <span class="p">|</span> xargs -I<span class="o">{}</span> <span class="nb">echo</span> <span class="s1">&#39;-v {}:{}&#39;</span><span class="k">)</span><span class="s2"> </span><span class="k">$(</span><span class="se">\l</span>s /usr/lib64/libnvidia* <span class="p">|</span> xargs -I<span class="o">{}</span> <span class="nb">echo</span> <span class="s1">&#39;-v {}:{}&#39;</span><span class="k">)</span><span class="s2">&quot;</span>
<span class="nb">export</span> <span class="nv">DEVICES</span><span class="o">=</span><span class="k">$(</span><span class="se">\l</span>s /dev/nvidia* <span class="p">|</span> xargs -I<span class="o">{}</span> <span class="nb">echo</span> <span class="s1">&#39;--device {}:{}&#39;</span><span class="k">)</span>
docker run <span class="si">${</span><span class="nv">CUDA_SO</span><span class="si">}</span> <span class="si">${</span><span class="nv">DEVICES</span><span class="si">}</span> -it paddledev/paddle:&lt;version&gt;-gpu
</pre></div>
</div>
</dd>
</dl>
</li>
<li><dl class="first docutils">
<dt>使用运行镜像发布你的AI程序</dt>
<dd><p class="first">假设您已经完成了一个AI训练的python程序 <code class="code docutils literal"><span class="pre">a.py</span></code>，这个程序是您在开发机上使用开发镜像完成开发。此时您可以运行这个命令在开发机上进行测试运行：</p>
<li><p class="first">运行以及发布您的AI程序</p>
<p>假设您已经完成了一个AI训练的python程序 <code class="code docutils literal"><span class="pre">a.py</span></code>，这个程序是您在开发机上使用开发镜像完成开发。此时您可以运行这个命令在开发机上进行测试运行：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it -v <span class="nv">$PWD</span>:/work paddle /work/a.py
</pre></div>
</div>
<p class="last">这里`a.py`包含的所有依赖假设都可以在Paddle的运行容器中。如果需要包含更多的依赖、或者需要发布您的应用的镜像，可以编写`Dockerfile`使用`FROM paddledev/paddle:&lt;version&gt;`
<p>如果要使用GPU，请运行：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>nvidia-docker run -it -v <span class="nv">$PWD</span>:/work paddle /work/a.py
</pre></div>
</div>
<p>这里`a.py`包含的所有依赖假设都可以在Paddle的运行容器中。如果需要包含更多的依赖、或者需要发布您的应用的镜像，可以编写`Dockerfile`使用`FROM paddledev/paddle:&lt;version&gt;`
创建和发布自己的AI程序镜像。</p>
</dd>
</dl>
</li>
</ol>
</div>
<div class="section" id="paddlepaddle">
<h2>运行PaddlePaddle书籍<a class="headerlink" href="#paddlepaddle" title="永久链接至标题"></a></h2>
<div class="section" id="paddlepaddle-book">
<h2>运行PaddlePaddle Book<a class="headerlink" href="#paddlepaddle-book" title="永久链接至标题"></a></h2>
<p>Jupyter Notebook是一个开源的web程序，大家可以通过它制作和分享带有代码、公式、图表、文字的交互式文档。用户可以通过网页浏览文档。</p>
<p>PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nodebook。
如果您想要更深入了解deep learning，PaddlePaddle书籍一定是您最好的选择。</p>
<p>我们提供可以直接运行PaddlePaddle书籍的docker镜像，直接运行：</p>
<p>PaddlePaddle Book是为用户和开发者制作的一个交互式的Jupyter Nodebook。
如果您想要更深入了解deep learning，PaddlePaddle Book一定是您最好的选择。</p>
<p>我们提供可以直接运行PaddlePaddle Book的Docker镜像，直接运行：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -p <span class="m">8888</span>:8888 paddlepaddle/book
</pre></div>
</div>
......@@ -311,36 +318,31 @@ docker run <span class="si">${</span><span class="nv">CUDA_SO</span><span class=
<h2>通过Docker容器开发PaddlePaddle<a class="headerlink" href="#dockerpaddlepaddle" title="永久链接至标题"></a></h2>
<p>开发人员可以在Docker开发镜像中开发PaddlePaddle。这样开发人员可以以一致的方式在不同的平台上工作 - Linux，Mac OS X和Windows。</p>
<ol class="arabic">
<li><p class="first">构建开发镜像</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>git clone --recursive https://github.com/PaddlePaddle/Paddle
<li><p class="first">制作PaddlePaddle开发镜像</p>
<p>PaddlePaddle每次发布新版本都会发布对应的开发镜像供开发者直接使用。这里介绍如生成造这个开发镜像。
生成Docker镜像的方式有两个，一个是直接把一个容器转换成镜像，另一个是创建Dockerfile并运行docker build指令按照Dockerfile生成镜像。第一个方法的好处是简单快捷，适合自己实验，可以快速迭代。第二个方法的好处是Dockerfile可以把整个生成流程描述很清楚，其他人很容易看懂镜像生成过程，持续集成系统也可以简单地复现这个过程。我们采用第二个方法。Dockerfile位于PaddlePaddle repo的根目录。生成生产镜像只需要运行：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>git clone https://github.com/PaddlePaddle/Paddle.git
<span class="nb">cd</span> Paddle
docker build -t paddle:dev .
</pre></div>
</div>
<p>请注意，默认情况下，<code class="code docutils literal"><span class="pre">docker</span> <span class="pre">build</span></code> 不会将源码导入到镜像中并编译它。如果我们想这样做，需要构建完开发镜像，然后执行：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -v <span class="nv">$PWD</span>:/paddle -e <span class="s2">&quot;WITH_GPU=OFF&quot;</span> -e <span class="s2">&quot;WITH_AVX=ON&quot;</span> -e <span class="s2">&quot;TEST=OFF&quot;</span> paddle:dev
</pre></div>
</div>
<p>docker build这个命令的-t指定了生成的镜像的名字，这里我们用paddle:dev。到此，PaddlePaddle开发镜像就被构建完毕了。</p>
</li>
<li><p class="first">运行开发环境</p>
<p>当我们编译好了 <code class="code docutils literal"><span class="pre">paddle:dev</span></code>， 我们可以在docker容器里做开发，源代码可以通过挂载本地文件来被载入Docker的开发环境里面：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d -p <span class="m">2202</span>:22 -v <span class="nv">$PWD</span>:/paddle paddle:dev sshd
<li><p class="first">制作PaddlePaddle生产镜像</p>
<p>生产镜像的生成分为两步，第一步是运行：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -v <span class="k">$(</span><span class="nb">pwd</span><span class="k">)</span>:/paddle -e <span class="s2">&quot;WITH_GPU=OFF&quot;</span> -e <span class="s2">&quot;WITH_AVX=OFF&quot;</span> -e <span class="s2">&quot;WITH_TEST=ON&quot;</span> paddle:dev
</pre></div>
</div>
<p>以上代码会启动一个带有PaddlePaddle开发环境的docker容器，源代码会被挂载到 <code class="code docutils literal"><span class="pre">/paddle</span></code> 。</p>
<p>以上的 <code class="code docutils literal"><span class="pre">docker</span> <span class="pre">run</span></code> 命令其实会启动一个在2202端口监听的SSHD服务器。这样，我们就能SSH进入我们的开发容器了：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>ssh root@localhost -p <span class="m">2202</span>
<p>以上命令会编译PaddlePaddle，生成运行程序，以及生成创建生产镜像的Dockerfile。所有生成的的文件都在build目录下。“WITH_GPU”控制生成的生产镜像是否支持GPU，“WITH_AVX”控制生成的生产镜像是否支持AVX，”WITH_TEST“控制是否生成单元测试。</p>
<p>第二步是运行：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker build -t paddle:prod -f build/Dockerfile .
</pre></div>
</div>
<p>以上命令会按照生成的Dockerfile把生成的程序拷贝到生产镜像中并做相应的配置，最终生成名为paddle:prod的生产镜像。</p>
</li>
<li><p class="first">在Docker开发环境中编译与安装PaddlPaddle代码</p>
<p>当在容器里面的时候，可以用脚本 <code class="code docutils literal"><span class="pre">paddle/scripts/docker/build.sh</span></code> 来编译、安装与测试PaddlePaddle：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>/paddle/paddle/scripts/docker/build.sh
</pre></div>
</div>
<p>以上指令会在 <code class="code docutils literal"><span class="pre">/paddle/build</span></code> 中编译PaddlePaddle。通过以下指令可以运行单元测试：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="nb">cd</span> /paddle/build
ctest
<li><p class="first">运行单元测试</p>
<p>运行以下指令：</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it -v <span class="k">$(</span><span class="nb">pwd</span><span class="k">)</span>:/paddle paddle:dev bash -c <span class="s2">&quot;cd /paddle/build &amp;&amp; ctest&quot;</span>
</pre></div>
</div>
</li>
......
develop/doc_cn/searchindex.js
浏览文件 @ da72b34c
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或