.. _sec_auto_para:
Paralelismo Automático
======================
.. raw:: html
.. raw:: html
O MXNet constrói automaticamente gráficos computacionais no *back-end*.
Usando um gráfico computacional, o sistema está ciente de todas as
dependências e pode executar seletivamente várias tarefas não
interdependentes em paralelo para melhorar a velocidade. Por exemplo,
:numref:fig_asyncgraph em :numref:sec_async inicializa duas variáveis
independentemente. Consequentemente, o sistema pode optar por
executá-los em paralelo.
.. raw:: html
.. raw:: html
O PyTorch constrói automaticamente gráficos computacionais no
*back-end*. Usando um gráfico computacional, o sistema está ciente de
todas as dependências e pode executar seletivamente várias tarefas não
interdependentes em paralelo para melhorar a velocidade. Por exemplo,
:numref:`fig_asyncgraph` em :numref:`sec_async` inicializa duas
variáveis independentemente. Consequentemente, o sistema pode optar por
executá-las em paralelo.
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
from mxnet import np, npx
from d2l import mxnet as d2l
npx.set_np()
.. raw:: html
.. raw:: html
.. code:: python
import torch
from d2l import torch as d2l
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
devices = d2l.try_all_gpus()
def run(x):
return [x.dot(x) for _ in range(50)]
x_gpu1 = np.random.uniform(size=(4000, 4000), ctx=devices[0])
x_gpu2 = np.random.uniform(size=(4000, 4000), ctx=devices[1])
Agora aplicamos a função aos dados. Para garantir que o cache não
desempenhe um papel nos resultados, aquecemos os dispositivos realizando
uma única passagem em cada um deles antes da medição.
.. code:: python
run(x_gpu1) # Warm-up both devices
run(x_gpu2)
npx.waitall()
with d2l.Benchmark('GPU1 time'):
run(x_gpu1)
npx.waitall()
with d2l.Benchmark('GPU2 time'):
run(x_gpu2)
npx.waitall()
.. parsed-literal::
:class: output
GPU1 time: 0.5087 sec
GPU2 time: 0.4951 sec
Se removermos o ``waitall ()`` entre as duas tarefas, o sistema fica
livre para paralelizar a computação em ambos os dispositivos
automaticamente.
.. code:: python
with d2l.Benchmark('GPU1 & GPU2'):
run(x_gpu1)
run(x_gpu2)
npx.waitall()
.. parsed-literal::
:class: output
GPU1 & GPU2: 0.5090 sec
No caso acima, o tempo total de execução é menor que a soma de suas
partes, uma vez que o MXNet programa automaticamente a computação em
ambos os dispositivos GPU sem a necessidade de um código sofisticado em
nome do usuário.
.. raw:: html
.. raw:: html
.. code:: python
devices = d2l.try_all_gpus()
def run(x):
return [x.mm(x) for _ in range(50)]
x_gpu1 = torch.rand(size=(4000, 4000), device=devices[0])
x_gpu2 = torch.rand(size=(4000, 4000), device=devices[1])
Agora aplicamos a função aos dados. Para garantir que o cache não
desempenhe um papel nos resultados, aquecemos os dispositivos realizando
uma única passagem em cada um deles antes da medição.
``torch.cuda.synchronize ()`` espera que todos os kernels em todos os
streams em um dispositivo CUDA sejam concluídos. Ele recebe um argumento
``device``, o dispositivo para o qual precisamos sincronizar. Ele usa o
dispositivo atual, fornecido por ``current_device ()``, se o argumento
do dispositivo for ``None`` (padrão).
.. code:: python
run(x_gpu1)
run(x_gpu2) # Warm-up all devices
torch.cuda.synchronize(devices[0])
torch.cuda.synchronize(devices[1])
with d2l.Benchmark('GPU 1 time'):
run(x_gpu1)
torch.cuda.synchronize(devices[0])
with d2l.Benchmark('GPU 2 time'):
run(x_gpu2)
torch.cuda.synchronize(devices[1])
.. parsed-literal::
:class: output
GPU 1 time: 0.4915 sec
GPU 2 time: 0.4926 sec
Se removermos ``torch.cuda.synchronize ()`` entre as duas tarefas, o
sistema fica livre para paralelizar a computação em ambos os
dispositivos automaticamente.
.. code:: python
with d2l.Benchmark('GPU1 & GPU2'):
run(x_gpu1)
run(x_gpu2)
torch.cuda.synchronize()
.. parsed-literal::
:class: output
GPU1 & GPU2: 0.4913 sec
No caso acima, o tempo total de execução é menor que a soma de suas
partes, uma vez que o PyTorch programa automaticamente a computação em
ambos os dispositivos GPU sem a necessidade de um código sofisticado em
nome do usuário.
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def copy_to_cpu(x):
return [y.copyto(npx.cpu()) for y in x]
with d2l.Benchmark('Run on GPU1'):
y = run(x_gpu1)
npx.waitall()
with d2l.Benchmark('Copy to CPU'):
y_cpu = copy_to_cpu(y)
npx.waitall()
.. parsed-literal::
:class: output
Run on GPU1: 0.5484 sec
Copy to CPU: 2.3873 sec
Isso é um tanto ineficiente. Observe que já podemos começar a copiar
partes de ``y`` para a CPU enquanto o restante da lista ainda está sendo
calculado. Essa situação ocorre, por exemplo, quando calculamos o
gradiente (*backprop*) em um minibatch. Os gradientes de alguns dos
parâmetros estarão disponíveis antes dos outros. Portanto, é vantajoso
começar a usar a largura de banda do barramento PCI-Express enquanto a
GPU ainda está em execução. Remover ``waitall`` entre as duas partes nos
permite simular este cenário.
.. code:: python
with d2l.Benchmark('Run on GPU1 and copy to CPU'):
y = run(x_gpu1)
y_cpu = copy_to_cpu(y)
npx.waitall()
.. parsed-literal::
:class: output
Run on GPU1 and copy to CPU: 2.5573 sec
.. raw:: html
.. raw:: html
.. code:: python
def copy_to_cpu(x, non_blocking=False):
return [y.to('cpu', non_blocking=non_blocking) for y in x]
with d2l.Benchmark('Run on GPU1'):
y = run(x_gpu1)
torch.cuda.synchronize()
with d2l.Benchmark('Copy to CPU'):
y_cpu = copy_to_cpu(y)
torch.cuda.synchronize()
.. parsed-literal::
:class: output
Run on GPU1: 0.4916 sec
Copy to CPU: 2.3453 sec
Isso é um tanto ineficiente. Observe que já podemos começar a copiar
partes de ``y`` para a CPU enquanto o restante da lista ainda está sendo
calculado. Essa situação ocorre, por exemplo, quando calculamos o
gradiente (*backprop*) em um minibatch. Os gradientes de alguns dos
parâmetros estarão disponíveis antes dos outros. Portanto, é vantajoso
começar a usar a largura de banda do barramento PCI-Express enquanto a
GPU ainda está em execução. No PyTorch, várias funções como ``to()`` e
``copy_()`` admitem um argumento ``non_blocking`` explícito, que permite
ao chamador ignorar a sincronização quando ela é desnecessária. Definir
``non_blocking = True`` nos permite simular este cenário.
.. code:: python
with d2l.Benchmark('Run on GPU1 and copy to CPU'):
y = run(x_gpu1)
y_cpu = copy_to_cpu(y, True)
torch.cuda.synchronize()
.. parsed-literal::
:class: output
Run on GPU1 and copy to CPU: 1.6498 sec
.. raw:: html
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html