As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Como funciona o paralelismo de tensores
<a name="model-parallel-extended-features-pytorch-tensor-parallelism-how-it-works"></a>

O paralelismo de tensores ocorre no nível de `nn.Modules`; ele particiona módulos específicos no modelo em classificações paralelas de tensores. Isso é um acréscimo à partição existente do *conjunto de módulos* usados no paralelismo de tubulações.

Quando um módulo é particionado por meio de paralelismo de tensores, sua propagação para frente e para trás é distribuída. A biblioteca gerencia a comunicação necessária entre dispositivos para implementar a execução distribuída desses módulos. Os módulos são particionados em várias classificações paralelas de dados. Ao contrário da distribuição tradicional de workloads, cada classificação paralela de dados **não** tem a réplica completa do modelo quando o paralelismo de tensores da biblioteca é usado. Em vez disso, cada classificação paralela de dados pode ter somente uma partição dos módulos distribuídos, além da totalidade dos módulos que não estão distribuídos.

**Exemplo:** considere o paralelismo de tensores em classificações paralelas de dados, em que o grau de paralelismo de dados é 4 e o grau de paralelismo de tensores é 2. Suponha que você tenha um grupo paralelo de dados que contém a seguinte árvore de módulos, depois de particionar o conjunto de módulos:

```
A
├── B
|   ├── E
|   ├── F
├── C
└── D
    ├── G
    └── H
```

Suponha que o paralelismo de tensores seja compatível com os módulos B, G e H. Um resultado possível da partição paralela de tensores desse modelo poderia ser:

```
dp_rank 0 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 1 (tensor parallel rank 1): A, B:1, C, D, G:1, H
dp_rank 2 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 3 (tensor parallel rank 1): A, B:1, C, D, G:1, H
```

Cada linha representa o conjunto de módulos armazenados na `dp_rank`, e a notação `X:y` representa a `y`-ésima fração do módulo `X`. Observe o seguinte:

1. O particionamento ocorre em subconjuntos de classificações paralelas de dados, que chamamos `TP_GROUP`, não de todo `DP_GROUP`, para que a partição exata do modelo seja replicada em `dp_rank` 0 e `dp_rank` 2 e, da mesma forma, em `dp_rank` 1 e `dp_rank` 3.

1. Os módulos `E` e não `F` fazem mais parte do modelo, pois seu módulo pai `B` é particionado e qualquer execução que normalmente faz parte `E` e `F` ocorre dentro do módulo `B` (particionado).

1. Embora `H` seja compatível com paralelismo de tensores, neste exemplo ele não é particionado, o que destaca que a partição de um módulo depende da entrada do usuário. O fato de um módulo ser compatível com paralelismo de tensores não significa necessariamente que ele seja particionado.

## Como a biblioteca adapta o paralelismo do tensor ao módulo PyTorch `nn.Linear`
<a name="model-parallel-extended-for-pytorch-adapt-to-module"></a>

Quando o paralelismo do tensor é executado em classificações paralelas de dados, um subconjunto dos parâmetros, gradientes e estados do otimizador é particionado nos dispositivos paralelos do tensor *para os módulos que são particionados*. Para o resto dos módulos, os dispositivos tensores paralelos operam de forma paralela de dados regular. Para executar o módulo particionado, um dispositivo primeiro coleta as partes necessárias de *todas as amostras de dados* em dispositivos pares no mesmo grupo de paralelismo de tensores. O dispositivo então executa a fração local do módulo em todas essas amostras de dados, seguida por outra rodada de sincronização que combina as partes da saída para cada amostra de dados e retorna as amostras de dados combinadas para a origem GPUs da amostra de dados. A figura a seguir mostra um exemplo desse processo em um módulo particionado `nn.Linear`. 

![\[Duas figuras mostrando dois conceitos paralelos de tensores.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-concept.png)


A primeira figura mostra um modelo pequeno com um módulo `nn.Linear` grande com paralelismo de dados nas duas classificações de paralelismo de tensores. O módulo `nn.Linear` é replicado em duas fileiras paralelas. 

A segunda figura mostra o paralelismo de tensores aplicado em um modelo maior durante a divisão do módulo `nn.Linear`. Cada `tp_rank` contém metade do módulo linear e a totalidade do resto das operações. Enquanto o módulo linear é executado, cada `tp_rank` coleta a metade relevante de todas as amostras de dados e a passa pela metade do módulo `nn.Linear`. O resultado precisa ser disperso por redução (com a soma como operação de redução) para que cada classificação tenha a saída linear final para suas próprias amostras de dados. O resto do modelo é executado da maneira paralela de dados típica.