提交 237bdf7a 编写于 作者: T Travis CI

Deploy to GitHub Pages: 1bca3cfd

上级 15c8ae78
......@@ -12,44 +12,91 @@ of your hardware resource on Mac OS X and Windows.
Usage of CPU-only and GPU Images
----------------------------------
For each version of PaddlePaddle, we release 2 Docker images, a
CPU-only one and a CUDA GPU one. We do so by configuring
`dockerhub.com <https://hub.docker.com/r/paddledev/paddle/>`_
automatically generate the latest docker images `paddledev/paddle:0.10.0rc1-cpu`
and `paddledev/paddle:0.10.0rc1-gpu`.
For each version of PaddlePaddle, we release 2 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 <https://hub.docker.com/r/paddledev/paddle/>`_. You can find the
latest versions under "tags" tab at dockerhub.com.
1. development image :code:`paddlepaddle/paddle:<version>-dev`
This image has packed related develop tools and runtime environment. Users and
developers can use this image instead of their own local computer to accomplish
development, build, releasing, document writing etc. While different version of
paddle may depends on different version of libraries and tools, if you want to
setup a local environment, you must pay attention to the versions.
The development image contains:
- gcc/clang
- nvcc
- Python
- sphinx
- woboq
- sshd
Many developers use servers with GPUs, they can use ssh to login to the server
and run :code:`docker exec` to enter the docker container and start their work.
Also they can start a development docker image with SSHD service, so they can login to
the container and start work.
To run the CPU-only image as an interactive container:
To run the CPU-only image as an interactive container:
.. code-block:: bash
.. code-block:: bash
docker run -it --rm paddledev/paddle:0.10.0rc1-cpu /bin/bash
docker run -it --rm paddledev/paddle:<version> /bin/bash
or, we can run it as a daemon container
or, we can run it as a daemon container
.. code-block:: bash
.. code-block:: bash
docker run -d -p 2202:22 -p 8888:8888 paddledev/paddle:0.10.0rc1-cpu
docker run -d -p 2202:22 -p 8888:8888 paddledev/paddle:<version>
and SSH to this container using password :code:`root`:
and SSH to this container using password :code:`root`:
.. code-block:: bash
.. code-block:: bash
ssh -p 2202 root@localhost
An advantage of using SSH is that we can connect to PaddlePaddle from
more than one terminals. For example, one terminal running vi and
another one running Python interpreter. Another advantage is that we
can run the PaddlePaddle container on a remote server and SSH to it
from a laptop.
An advantage of using SSH is that we can connect to PaddlePaddle from
more than one terminals. For example, one terminal running vi and
another one running Python interpreter. Another advantage is that we
can run the PaddlePaddle container on a remote server and SSH to it
from a laptop.
Above methods work with the GPU image too -- just please don't forget
to install CUDA driver and let Docker knows about it:
.. code-block:: bash
2. Production images, this image might have multiple variants:
- 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`
Please be aware that the CPU-only and the GPU images both use the AVX
instruction set, but old computers produced before 2008 do not support
AVX. The following command checks if your Linux computer supports
AVX:
.. code-block:: bash
if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
If it doesn't, we will use the non-AVX images.
Notice please don't forget
to install CUDA driver and let Docker knows about it:
.. 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 paddledev/paddle:0.10.0rc1-gpu
docker run ${CUDA_SO} ${DEVICES} -it paddledev/paddle:<version>-gpu
3. Use production image to release you AI application
Suppose that we have a simple application program in :code:`a.py`, we can test and run it using the production image:
```bash
docker run -it -v $PWD:/work paddle /work/a.py
```
But this works only if all dependencies of :code:`a.py` are in the production image. If this is not the case, we need to build a new Docker image from the production image and with more dependencies installs.
PaddlePaddle Book
......@@ -63,11 +110,11 @@ PaddlePaddle Book is an interactive Jupyter Notebook for users and developers.
We already exposed port 8888 for this book. If you want to
dig deeper into deep learning, PaddlePaddle Book definitely is your best choice.
Once you are inside the container, simply issue the command:
We provide a packaged book image, simply issue the command:
.. code-block:: bash
jupyter notebook
docker run -p 8888:8888 paddlepaddle/book
Then, you would back and paste the address into the local browser:
......@@ -77,32 +124,6 @@ Then, you would back and paste the address into the local browser:
That's all. Enjoy your journey!
Non-AVX Images
--------------
Please be aware that the CPU-only and the GPU images both use the AVX
instruction set, but old computers produced before 2008 do not support
AVX. The following command checks if your Linux computer supports
AVX:
.. code-block:: bash
if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
If it doesn't, we will need to build non-AVX images manually from
source code:
.. code-block:: bash
cd ~
git clone https://github.com/PaddlePaddle/Paddle.git
cd Paddle
docker build --build-arg WITH_AVX=OFF -t paddle:cpu-noavx -f paddle/scripts/docker/Dockerfile .
docker build --build-arg WITH_AVX=OFF -t paddle:gpu-noavx -f paddle/scripts/docker/Dockerfile.gpu .
Development Using Docker
------------------------
......@@ -110,22 +131,21 @@ Developers can work on PaddlePaddle using Docker. This allows
developers to work on different platforms -- Linux, Mac OS X, and
Windows -- in a consistent way.
1. Build the Development Environment as a Docker Image
1. Build the Development Docker Image
.. code-block:: bash
git clone --recursive https://github.com/PaddlePaddle/Paddle
cd Paddle
docker build -t paddle:dev -f paddle/scripts/docker/Dockerfile .
docker build -t paddle:dev .
Note that by default :code:`docker build` wouldn't import source
tree into the image and build it. If we want to do that, we need
to set a build arg:
tree into the image and build it. If we want to do that, we need docker the
development docker image and then run the following command:
.. code-block:: bash
docker build -t paddle:dev -f paddle/scripts/docker/Dockerfile --build-arg BUILD_AND_INSTALL=ON .
docker run -v $PWD:/paddle -e "WITH_GPU=OFF" -e "WITH_AVX=ON" -e "TEST=OFF" paddle:dev
2. Run the Development Environment
......@@ -136,14 +156,13 @@ Windows -- in a consistent way.
.. code-block:: bash
docker run -d -p 2202:22 -p 8888:8888 -v $PWD:/paddle paddle:dev
docker run -d -p 2202:22 -p 8888:8888 -v $PWD:/paddle paddle:dev sshd
This runs a container of the development environment Docker image
with the local source tree mounted to :code:`/paddle` of the
container.
Note that the default entry-point of :code:`paddle:dev` is
:code:`sshd`, and above :code:`docker run` commands actually starts
The above :code:`docker run` commands actually starts
an SSHD server listening on port 2202. This allows us to log into
this container with:
......@@ -191,7 +210,7 @@ container:
.. code-block:: bash
docker run -d --name paddle-cpu-doc paddle:0.10.0rc1-cpu
docker run -d --name paddle-cpu-doc paddle:<version>
docker run -d --volumes-from paddle-cpu-doc -p 8088:80 nginx
......
......@@ -178,7 +178,6 @@
<li><a class="reference internal" href="#">PaddlePaddle in Docker Containers</a><ul>
<li><a class="reference internal" href="#usage-of-cpu-only-and-gpu-images">Usage of CPU-only and GPU Images</a></li>
<li><a class="reference internal" href="#paddlepaddle-book">PaddlePaddle Book</a></li>
<li><a class="reference internal" href="#non-avx-images">Non-AVX Images</a></li>
<li><a class="reference internal" href="#development-using-docker">Development Using Docker</a></li>
<li><a class="reference internal" href="#documentation">Documentation</a></li>
</ul>
......@@ -223,17 +222,35 @@ Please be aware that you will need to change <a class="reference external" href=
of your hardware resource on Mac OS X and Windows.</p>
<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 2 Docker images, a
CPU-only one and a CUDA GPU one. We do so by configuring
<a class="reference external" href="https://hub.docker.com/r/paddledev/paddle/">dockerhub.com</a>
automatically generate the latest docker images <cite>paddledev/paddle:0.10.0rc1-cpu</cite>
and <cite>paddledev/paddle:0.10.0rc1-gpu</cite>.</p>
<p>For each version of PaddlePaddle, we release 2 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.
1. development image <code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;-dev</span></code></p>
<blockquote>
<div><p>This image has packed related develop tools and runtime environment. Users and
developers can use this image instead of their own local computer to accomplish
development, build, releasing, document writing etc. While different version of
paddle may depends on different version of libraries and tools, if you want to
setup a local environment, you must pay attention to the versions.
The development image contains:
- gcc/clang
- nvcc
- Python
- sphinx
- woboq
- sshd
Many developers use servers with GPUs, they can use ssh to login to the server
and run <code class="code docutils literal"><span class="pre">docker</span> <span class="pre">exec</span></code> to enter the docker container and start their work.
Also they can start a development docker image with SSHD service, so they can login to
the container and start work.</p>
<p>To run the CPU-only image as an interactive container:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it --rm paddledev/paddle:0.10.0rc1-cpu /bin/bash
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it --rm paddledev/paddle:&lt;version&gt; /bin/bash
</pre></div>
</div>
<p>or, we can run it as a daemon container</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d -p <span class="m">2202</span>:22 -p <span class="m">8888</span>:8888 paddledev/paddle:0.10.0rc1-cpu
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d -p <span class="m">2202</span>:22 -p <span class="m">8888</span>:8888 paddledev/paddle:&lt;version&gt;
</pre></div>
</div>
<p>and SSH to this container using password <code class="code docutils literal"><span class="pre">root</span></code>:</p>
......@@ -245,13 +262,47 @@ more than one terminals. For example, one terminal running vi and
another one running Python interpreter. Another advantage is that we
can run the PaddlePaddle container on a remote server and SSH to it
from a laptop.</p>
<p>Above methods work with the GPU image too &#8211; just please don&#8217;t forget
</div></blockquote>
<ol class="arabic" start="2">
<li><dl class="first docutils">
<dt>Production images, this image might have multiple variants:</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/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/no-AVX:<code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;-noavx</span></code></li>
</ul>
<p>Please be aware that the CPU-only and the GPU images both use the AVX
instruction set, but old computers produced before 2008 do not support
AVX. The following command checks if your Linux computer supports
AVX:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
If it doesn&#39;t, we will use the non-AVX images.
</pre></div>
</div>
<p>Notice please don&#8217;t forget
to install CUDA driver and let Docker knows about it:</p>
<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>
<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>
<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:0.10.0rc1-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>
</div>
</dd>
</dl>
</li>
<li><dl class="first docutils">
<dt>Use production image to release you AI application</dt>
<dd><p class="first">Suppose that we have a simple application program in <code class="code docutils literal"><span class="pre">a.py</span></code>, we can test and run it using the production image:</p>
<p><code class="docutils literal"><span class="pre">`bash</span>
<span class="pre">docker</span> <span class="pre">run</span> <span class="pre">-it</span> <span class="pre">-v</span> <span class="pre">$PWD:/work</span> <span class="pre">paddle</span> <span class="pre">/work/a.py</span>
<span class="pre">`</span></code></p>
<p class="last">But this works only if all dependencies of <code class="code docutils literal"><span class="pre">a.py</span></code> are in the production image. If this is not the case, we need to build a new Docker image from the production image and with more dependencies installs.</p>
</dd>
</dl>
</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>
......@@ -261,8 +312,8 @@ visualizations and explanatory text in a single browser.</p>
<p>PaddlePaddle Book is an interactive Jupyter Notebook for users and developers.
We already exposed port 8888 for this book. If you want to
dig deeper into deep learning, PaddlePaddle Book definitely is your best choice.</p>
<p>Once you are inside the container, simply issue the command:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>jupyter notebook
<p>We provide a packaged book image, simply issue the command:</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>
<p>Then, you would back and paste the address into the local browser:</p>
......@@ -271,41 +322,22 @@ dig deeper into deep learning, PaddlePaddle Book definitely is your best choice.
</div>
<p>That&#8217;s all. Enjoy your journey!</p>
</div>
<div class="section" id="non-avx-images">
<h2>Non-AVX Images<a class="headerlink" href="#non-avx-images" title="Permalink to this headline"></a></h2>
<p>Please be aware that the CPU-only and the GPU images both use the AVX
instruction set, but old computers produced before 2008 do not support
AVX. The following command checks if your Linux computer supports
AVX:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="k">if</span> cat /proc/cpuinfo <span class="p">|</span> grep -i avx<span class="p">;</span> <span class="k">then</span> <span class="nb">echo</span> Yes<span class="p">;</span> <span class="k">else</span> <span class="nb">echo</span> No<span class="p">;</span> <span class="k">fi</span>
</pre></div>
</div>
<p>If it doesn&#8217;t, we will need to build non-AVX images manually from
source code:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="nb">cd</span> ~
git clone https://github.com/PaddlePaddle/Paddle.git
<span class="nb">cd</span> Paddle
docker build --build-arg <span class="nv">WITH_AVX</span><span class="o">=</span>OFF -t paddle:cpu-noavx -f paddle/scripts/docker/Dockerfile .
docker build --build-arg <span class="nv">WITH_AVX</span><span class="o">=</span>OFF -t paddle:gpu-noavx -f paddle/scripts/docker/Dockerfile.gpu .
</pre></div>
</div>
</div>
<div class="section" id="development-using-docker">
<h2>Development Using Docker<a class="headerlink" href="#development-using-docker" title="Permalink to this headline"></a></h2>
<p>Developers can work on PaddlePaddle using Docker. This allows
developers to work on different platforms &#8211; Linux, Mac OS X, and
Windows &#8211; in a consistent way.</p>
<ol class="arabic">
<li><p class="first">Build the Development Environment as a Docker Image</p>
<li><p class="first">Build the Development Docker Image</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>git clone --recursive https://github.com/PaddlePaddle/Paddle
<span class="nb">cd</span> Paddle
docker build -t paddle:dev -f paddle/scripts/docker/Dockerfile .
docker build -t paddle:dev .
</pre></div>
</div>
<p>Note that by default <code class="code docutils literal"><span class="pre">docker</span> <span class="pre">build</span></code> wouldn&#8217;t import source
tree into the image and build it. If we want to do that, we need
to set a build arg:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker build -t paddle:dev -f paddle/scripts/docker/Dockerfile --build-arg <span class="nv">BUILD_AND_INSTALL</span><span class="o">=</span>ON .
tree into the image and build it. If we want to do that, we need docker the
development docker image and then run the following command:</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>
......@@ -313,14 +345,13 @@ to set a build arg:</p>
<p>Once we got the image <code class="code docutils literal"><span class="pre">paddle:dev</span></code>, we can use it to develop
Paddle by mounting the local source code tree into a container that
runs the image:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d -p <span class="m">2202</span>:22 -p <span class="m">8888</span>:8888 -v <span class="nv">$PWD</span>:/paddle paddle:dev
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d -p <span class="m">2202</span>:22 -p <span class="m">8888</span>:8888 -v <span class="nv">$PWD</span>:/paddle paddle:dev sshd
</pre></div>
</div>
<p>This runs a container of the development environment Docker image
with the local source tree mounted to <code class="code docutils literal"><span class="pre">/paddle</span></code> of the
container.</p>
<p>Note that the default entry-point of <code class="code docutils literal"><span class="pre">paddle:dev</span></code> is
<code class="code docutils literal"><span class="pre">sshd</span></code>, and above <code class="code docutils literal"><span class="pre">docker</span> <span class="pre">run</span></code> commands actually starts
<p>The above <code class="code docutils literal"><span class="pre">docker</span> <span class="pre">run</span></code> commands actually starts
an SSHD server listening on port 2202. This allows us to log into
this container with:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>ssh root@localhost -p <span class="m">2202</span>
......@@ -356,7 +387,7 @@ for users to browse and understand the C++ source code.</p>
<p>As long as we give the Paddle Docker container a name, we can run an
additional Nginx Docker container to serve the volume from the Paddle
container:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d --name paddle-cpu-doc paddle:0.10.0rc1-cpu
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d --name paddle-cpu-doc paddle:&lt;version&gt;
docker run -d --volumes-from paddle-cpu-doc -p <span class="m">8088</span>:80 nginx
</pre></div>
</div>
......
此差异已折叠。
......@@ -4,42 +4,76 @@ PaddlePaddle的Docker容器使用方式
PaddlePaddle目前唯一官方支持的运行的方式是Docker容器。因为Docker能在所有主要操作系统(包括Linux,Mac OS X和Windows)上运行。 请注意,您需要更改 `Dockers设置 <https://github.com/PaddlePaddle/Paddle/issues/627>`_ 才能充分利用Mac OS X和Windows上的硬件资源。
纯CPU和GPU的docker镜像使用说明
PaddlePaddle发布的docker镜像使用说明
------------------------------
对于每一个PaddlePaddle版本,我们都会发布两个Docker镜像:纯CPU的和GPU的
我们通过设置 `dockerhub.com <https://hub.docker.com/r/paddledev/paddle/>`_ 自动生成最新的docker镜像:
`paddledev/paddle:0.10.0rc1-cpu` 和 `paddledev/paddle:0.10.0rc1-gpu`。
对于每一个PaddlePaddle版本,我们都会发布两种Docker镜像:开发镜像、运行镜像。运行镜像包括纯CPU版本和GPU版本以及其对应的非AVX版本
我们会在 `dockerhub.com <https://hub.docker.com/r/paddledev/paddle/>`_ 提供最新的docker镜像,可以在"tags"标签下找到最新的Paddle镜像版本。
1. 开发镜像::code:`paddlepaddle/paddle:<version>-dev`
以交互容器方式运行纯CPU的镜像:
这个镜像包含了Paddle相关的开发工具以及编译和运行环境。用户可以使用开发镜像代替配置本地环境,完成开发,编译,发布,
文档编写等工作。由于不同的Paddle的版本可能需要不同的依赖和工具,所以如果需要自行配置开发环境需要考虑版本的因素。
开发镜像包含了以下工具:
- gcc/clang
- nvcc
- Python
- sphinx
- woboq
- sshd
很多开发者会使用远程的安装有GPU的服务器工作,用户可以使用ssh登录到这台服务器上并执行 :code:`docker exec`进入开发镜像并开始工作,
也可以在开发镜像中启动一个SSHD服务,方便开发者直接登录到镜像中进行开发:
.. code-block:: bash
以交互容器方式运行开发镜像:
.. code-block:: bash
docker run -it --rm paddledev/paddle:0.10.0rc1-cpu /bin/bash
docker run -it --rm paddledev/paddle:<version>-dev /bin/bash
或者,可以以后台进程方式运行容器:
或者,可以以后台进程方式运行容器:
.. code-block:: bash
.. code-block:: bash
docker run -d -p 2202:22 -p 8888:8888 paddledev/paddle:0.10.0rc1-cpu
docker run -d -p 2202:22 -p 8888:8888 paddledev/paddle:<version>-dev
然后用密码 :code:`root` SSH进入容器:
然后用密码 :code:`root` SSH进入容器:
.. code-block:: bash
.. code-block:: bash
ssh -p 2202 root@localhost
SSH方式的一个优点是我们可以从多个终端进入容器。比如,一个终端运行vi,另一个终端运行Python。另一个好处是我们可以把PaddlePaddle容器运行在远程服务器上,并在笔记本上通过SSH与其连接。
SSH方式的一个优点是我们可以从多个终端进入容器。比如,一个终端运行vi,另一个终端运行Python。另一个好处是我们可以把PaddlePaddle容器运行在远程服务器上,并在笔记本上通过SSH与其连接。
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镜像里也能用-只是请不要忘记按装CUDA驱动,以及告诉Docker
纯CPU镜像以及GPU镜像都会用到AVX指令集,但是2008年之前生产的旧电脑不支持AVX。以下指令能检查Linux电脑是否支持AVX
.. code-block:: bash
.. code-block:: bash
if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
如果输出是No,就需要选择使用no-AVX的镜像
注意:在运行GPU版本的镜像时 安装CUDA驱动,以及告诉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 paddledev/paddle:0.10.0rc1-gpu
docker run ${CUDA_SO} ${DEVICES} -it paddledev/paddle:<version>-gpu
3. 使用运行镜像发布你的AI程序
假设您已经完成了一个AI训练的python程序 :code:`a.py`,这个程序是您在开发机上使用开发镜像完成开发。此时您可以运行这个命令在开发机上进行测试运行:
.. code-block:: bash
docker run -it -v $PWD:/work paddle /work/a.py
这里`a.py`包含的所有依赖假设都可以在Paddle的运行容器中。如果需要包含更多的依赖、或者需要发布您的应用的镜像,可以编写`Dockerfile`使用`FROM paddledev/paddle:<version>`
创建和发布自己的AI程序镜像。
运行PaddlePaddle书籍
---------------------
......@@ -49,11 +83,11 @@ Jupyter Notebook是一个开源的web程序,大家可以通过它制作和分
PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nodebook。
如果您想要更深入了解deep learning,PaddlePaddle书籍一定是您最好的选择。
当您进入容器内之后,只用运行以下命令
我们提供可以直接运行PaddlePaddle书籍的docker镜像,直接运行
.. code-block:: bash
jupyter notebook
docker run -p 8888:8888 paddlepaddle/book
然后在浏览器中输入以下网址:
......@@ -63,46 +97,25 @@ PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nod
就这么简单,享受您的旅程!
非AVX镜像
---------
纯CPU镜像以及GPU镜像都会用到AVX指令集,但是2008年之前生产的旧电脑不支持AVX。以下指令能检查Linux电脑是否支持AVX:
.. code-block:: bash
if cat /proc/cpuinfo | grep -i avx; then echo Yes; else echo No; fi
如果输出是No,我们就需要手动编译一个非AVX版本的镜像:
.. code-block:: bash
cd ~
git clone https://github.com/PaddlePaddle/Paddle.git
cd Paddle
docker build --build-arg WITH_AVX=OFF -t paddle:cpu-noavx -f paddle/scripts/docker/Dockerfile .
docker build --build-arg WITH_AVX=OFF -t paddle:gpu-noavx -f paddle/scripts/docker/Dockerfile.gpu .
通过Docker容器开发PaddlePaddle
------------------------------
开发人员可以在Docker中开发PaddlePaddle。这样开发人员可以以一致的方式在不同的平台上工作 - Linux,Mac OS X和Windows。
开发人员可以在Docker开发镜像中开发PaddlePaddle。这样开发人员可以以一致的方式在不同的平台上工作 - Linux,Mac OS X和Windows。
1. 将开发环境构建为Docker镜像
1. 构建开发镜像
.. code-block:: bash
git clone --recursive https://github.com/PaddlePaddle/Paddle
cd Paddle
docker build -t paddle:dev -f paddle/scripts/docker/Dockerfile .
docker build -t paddle:dev .
请注意,默认情况下,:code:`docker build` 不会将源码导入到镜像中并编译它。如果我们想这样做,需要设置一个参数
请注意,默认情况下,:code:`docker build` 不会将源码导入到镜像中并编译它。如果我们想这样做,需要构建完开发镜像,然后执行
.. code-block:: bash
docker build -t paddle:dev -f paddle/scripts/docker/Dockerfile --build-arg BUILD_AND_INSTALL=ON .
docker run -v $PWD:/paddle -e "WITH_GPU=OFF" -e "WITH_AVX=ON" -e "TEST=OFF" paddle:dev
2. 运行开发环境
......@@ -111,11 +124,11 @@ PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nod
.. code-block:: bash
docker run -d -p 2202:22 -v $PWD:/paddle paddle:dev
docker run -d -p 2202:22 -v $PWD:/paddle paddle:dev sshd
以上代码会启动一个带有PaddlePaddle开发环境的docker容器,源代码会被挂载到 :code:`/paddle` 。
请注意, :code:`paddle:dev` 的默认入口是 :code:`sshd` 。以上的 :code:`docker run` 命令其实会启动一个在2202端口监听的SSHD服务器。这样,我们就能SSH进入我们的开发容器了:
以上的 :code:`docker run` 命令其实会启动一个在2202端口监听的SSHD服务器。这样,我们就能SSH进入我们的开发容器了:
.. code-block:: bash
......@@ -140,14 +153,14 @@ PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nod
文档
----
Paddle的Docker镜像带有一个通过 `woboq code browser
Paddle的Docker开发镜像带有一个通过 `woboq code browser
<https://github.com/woboq/woboq_codebrowser>`_ 生成的HTML版本的C++源代码,便于用户浏览C++源码。
只要在Docker里启动PaddlePaddle的时候给它一个名字,就可以再运行另一个Nginx Docker镜像来服务HTML代码:
.. code-block:: bash
docker run -d --name paddle-cpu-doc paddle:0.10.0rc1-cpu
docker run -d --name paddle-cpu-doc paddle:<version>-dev
docker run -d --volumes-from paddle-cpu-doc -p 8088:80 nginx
接着我们就能够打开浏览器在 http://localhost:8088/paddle/ 浏览代码。
......@@ -183,11 +183,10 @@
<nav class="local-toc"><ul>
<li><a class="reference internal" href="#">PaddlePaddle的Docker容器使用方式</a><ul>
<li><a class="reference internal" href="#cpugpudocker">纯CPU和GPU的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="#avx">非AVX镜像</a></li>
<li><a class="reference internal" href="#dockerpaddlepaddle">通过Docker容器开发PaddlePaddle</a></li>
<li><a class="reference internal" href="#id1">文档</a></li>
<li><a class="reference internal" href="#id4">文档</a></li>
</ul>
</li>
</ul>
......@@ -224,17 +223,29 @@
<div class="section" id="paddlepaddledocker">
<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="cpugpudocker">
<h2>纯CPU和GPU的docker镜像使用说明<a class="headerlink" href="#cpugpudocker" title="永久链接至标题"></a></h2>
<p>对于每一个PaddlePaddle版本,我们都会发布两个Docker镜像:纯CPU的和GPU的。
我们通过设置 <a class="reference external" href="https://hub.docker.com/r/paddledev/paddle/">dockerhub.com</a> 自动生成最新的docker镜像:
<cite>paddledev/paddle:0.10.0rc1-cpu</cite><cite>paddledev/paddle:0.10.0rc1-gpu</cite></p>
<p>以交互容器方式运行纯CPU的镜像:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -it --rm paddledev/paddle:0.10.0rc1-cpu /bin/bash
<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相关的开发工具以及编译和运行环境。用户可以使用开发镜像代替配置本地环境,完成开发,编译,发布,
文档编写等工作。由于不同的Paddle的版本可能需要不同的依赖和工具,所以如果需要自行配置开发环境需要考虑版本的因素。
开发镜像包含了以下工具:
- gcc/clang
- nvcc
- Python
- sphinx
- woboq
- sshd
很多开发者会使用远程的安装有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
</pre></div>
</div>
<p>或者,可以以后台进程方式运行容器:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d -p <span class="m">2202</span>:22 -p <span class="m">8888</span>:8888 paddledev/paddle:0.10.0rc1-cpu
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d -p <span class="m">2202</span>:22 -p <span class="m">8888</span>:8888 paddledev/paddle:&lt;version&gt;-dev
</pre></div>
</div>
<p>然后用密码 <code class="code docutils literal"><span class="pre">root</span></code> SSH进入容器:</p>
......@@ -242,20 +253,50 @@
</pre></div>
</div>
<p>SSH方式的一个优点是我们可以从多个终端进入容器。比如,一个终端运行vi,另一个终端运行Python。另一个好处是我们可以把PaddlePaddle容器运行在远程服务器上,并在笔记本上通过SSH与其连接。</p>
<p>以上方法在GPU镜像里也能用-只是请不要忘记按装CUDA驱动,以及告诉Docker:</p>
<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>
</div></blockquote>
<ol class="arabic" start="2">
<li><dl class="first docutils">
<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/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/no-AVX:<code class="code docutils literal"><span class="pre">paddlepaddle/paddle:&lt;version&gt;-noavx</span></code></li>
</ul>
<p>纯CPU镜像以及GPU镜像都会用到AVX指令集,但是2008年之前生产的旧电脑不支持AVX。以下指令能检查Linux电脑是否支持AVX:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="k">if</span> cat /proc/cpuinfo <span class="p">|</span> grep -i avx<span class="p">;</span> <span class="k">then</span> <span class="nb">echo</span> Yes<span class="p">;</span> <span class="k">else</span> <span class="nb">echo</span> No<span class="p">;</span> <span class="k">fi</span>
</pre></div>
</div>
<p>如果输出是No,就需要选择使用no-AVX的镜像</p>
<p>注意:在运行GPU版本的镜像时 安装CUDA驱动,以及告诉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>
<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:0.10.0rc1-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>
</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>
<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;`
创建和发布自己的AI程序镜像。</p>
</dd>
</dl>
</li>
</ol>
</div>
<div class="section" id="paddlepaddle">
<h2>运行PaddlePaddle书籍<a class="headerlink" href="#paddlepaddle" title="永久链接至标题"></a></h2>
<p>Jupyter Notebook是一个开源的web程序,大家可以通过它制作和分享带有代码、公式、图表、文字的交互式文档。用户可以通过网页浏览文档。</p>
<p>PaddlePaddle书籍是为用户和开发者制作的一个交互式的Jupyter Nodebook。
如果您想要更深入了解deep learning,PaddlePaddle书籍一定是您最好的选择。</p>
<p>当您进入容器内之后,只用运行以下命令</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>jupyter notebook
<p>我们提供可以直接运行PaddlePaddle书籍的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>
<p>然后在浏览器中输入以下网址:</p>
......@@ -264,43 +305,28 @@ docker run <span class="si">${</span><span class="nv">CUDA_SO</span><span class=
</div>
<p>就这么简单,享受您的旅程!</p>
</div>
<div class="section" id="avx">
<h2>非AVX镜像<a class="headerlink" href="#avx" title="永久链接至标题"></a></h2>
<p>纯CPU镜像以及GPU镜像都会用到AVX指令集,但是2008年之前生产的旧电脑不支持AVX。以下指令能检查Linux电脑是否支持AVX:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="k">if</span> cat /proc/cpuinfo <span class="p">|</span> grep -i avx<span class="p">;</span> <span class="k">then</span> <span class="nb">echo</span> Yes<span class="p">;</span> <span class="k">else</span> <span class="nb">echo</span> No<span class="p">;</span> <span class="k">fi</span>
</pre></div>
</div>
<p>如果输出是No,我们就需要手动编译一个非AVX版本的镜像:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span><span class="nb">cd</span> ~
git clone https://github.com/PaddlePaddle/Paddle.git
<span class="nb">cd</span> Paddle
docker build --build-arg <span class="nv">WITH_AVX</span><span class="o">=</span>OFF -t paddle:cpu-noavx -f paddle/scripts/docker/Dockerfile .
docker build --build-arg <span class="nv">WITH_AVX</span><span class="o">=</span>OFF -t paddle:gpu-noavx -f paddle/scripts/docker/Dockerfile.gpu .
</pre></div>
</div>
</div>
<div class="section" id="dockerpaddlepaddle">
<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">
<li><p class="first">将开发环境构建为Docker镜像</p>
<li><p class="first">构建开发镜像</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>git clone --recursive https://github.com/PaddlePaddle/Paddle
<span class="nb">cd</span> Paddle
docker build -t paddle:dev -f paddle/scripts/docker/Dockerfile .
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 build -t paddle:dev -f paddle/scripts/docker/Dockerfile --build-arg <span class="nv">BUILD_AND_INSTALL</span><span class="o">=</span>ON .
<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>
</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
<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
</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">paddle:dev</span></code> 的默认入口是 <code class="code docutils literal"><span class="pre">sshd</span></code>以上的 <code class="code docutils literal"><span class="pre">docker</span> <span class="pre">run</span></code> 命令其实会启动一个在2202端口监听的SSHD服务器。这样,我们就能SSH进入我们的开发容器了:</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>
</pre></div>
</div>
......@@ -318,11 +344,11 @@ ctest
</li>
</ol>
</div>
<div class="section" id="id1">
<h2>文档<a class="headerlink" href="#id1" title="永久链接至标题"></a></h2>
<p>Paddle的Docker镜像带有一个通过 <a class="reference external" href="https://github.com/woboq/woboq_codebrowser">woboq code browser</a> 生成的HTML版本的C++源代码,便于用户浏览C++源码。</p>
<div class="section" id="id4">
<h2>文档<a class="headerlink" href="#id4" title="永久链接至标题"></a></h2>
<p>Paddle的Docker开发镜像带有一个通过 <a class="reference external" href="https://github.com/woboq/woboq_codebrowser">woboq code browser</a> 生成的HTML版本的C++源代码,便于用户浏览C++源码。</p>
<p>只要在Docker里启动PaddlePaddle的时候给它一个名字,就可以再运行另一个Nginx Docker镜像来服务HTML代码:</p>
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d --name paddle-cpu-doc paddle:0.10.0rc1-cpu
<div class="highlight-bash"><div class="highlight"><pre><span></span>docker run -d --name paddle-cpu-doc paddle:&lt;version&gt;-dev
docker run -d --volumes-from paddle-cpu-doc -p <span class="m">8088</span>:80 nginx
</pre></div>
</div>
......
此差异已折叠。
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册