提交 da72b34c 编写于 作者: T Travis CI

Deploy to GitHub Pages: c99bef61

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