allreduce、reduce、broadcast和reduce-scatter

这些都是分布式计算中常用的通信操作。

- Allreduce：所有进程将数据集合到一个位置，并且每个进程都获得最终结果。通俗点说，就是所有进程把自己的数据加起来，然后结果广播给所有进程。Allreduce 是一种非常有用的操作，它可以用于并行计算中的梯度聚合等操作。

- Reduce：将所有进程中的数据聚合成一个值，并将该值广播给所有进程。Reduce 操作通常用于并行计算中的求和、求平均等聚合操作。

- Broadcast：将某个进程中的数据广播给所有其他进程。Broadcast 操作通常用于分布式训练中的参数同步等操作。

- Reduce-scatter：首先，将数据划分为若干块，然后将每个进程的一部分数据与其他进程聚合，最后每个进程都会获得聚合结果中相应块的一部分数据。Reduce-scatter 操作通常用于并行计算中的数据划分和聚合操作。

以上四种通信操作都是分布式计算中必不可少的，可以帮助提高计算效率和性能。

相关问题

除了dist.all_reduce（tensor，op，group）之外，PyTorch目前共有6个集体。

是的，除了`dist.all_reduce(tensor, op, group)`，PyTorch目前还有以下5个集体操作：

1. `dist.broadcast(tensor, src, group=group)`：将张量从指定源广播到所有其他进程。

2. `dist.all_gather(tensor_list, tensor, group=group)`：将每个进程的张量列表收集到一个张量列表中，其中第i个张量列表包含特定进程的第i个张量。

3. `dist.reduce(tensor, dst, op=ReduceOp.SUM, group=group)`：将所有进程的张量缩减为单个张量，并将结果发送到指定的目标进程。

4. `dist.scatter(tensor, scatter_list, src, group=group)`：将张量分散到所有其他进程，其中每个进程接收到的张量是scatter_list中特定进程的一个子集。

5. `dist.gather(tensor, gather_list, dst, group=group)`：将所有进程的张量收集到指定的目标进程的张量列表中，其中第i个张量列表包含特定进程的第i个张量。

这些集体操作可用于在分布式环境中进行通信和同步，以便同时训练模型的多个进程可以相互通信和共享信息。

On considère une matrice carrée réelle A, de taille n × n. On souhaite calculer, en parallèle et en utilisant MPI, la trace de la matrice A, avec Trace(A) = aii . 𝑖=1 𝑛 ∑ Ecrire un programme MPI (en utilisant des communications collectives et de réductions) qui effectue les actions suivantes (2,5 points) : - La machine de rang 0 initialise la matrice A et la distribue sur p machines. On considère cette distribution par lignes et on suppose que n est divisible par p, - Chaque machine calcule la trace locale correspondant à sa portion de la matrice A, - La machine de rang 0 récupère toutes les traces locales pour calculer la trace globale de la matrice

Voici un exemple de programme MPI qui calcule la trace d'une matrice distribuée par lignes :

#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>

int main(int argc, char** argv) {
    int rank, size, n, p, i, j;
    double *A, *localA, localTrace, globalTrace;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    // Lecture de la taille de la matrice
    if (rank == 0) {
        printf("Entrez la taille de la matrice : ");
        scanf("%d", &n);
    }

    // Broadcast de la taille de la matrice
    MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);

    // Calcul de la taille locale de la matrice
    p = n / size;
    localA = (double*) malloc(p * n * sizeof(double));

    // Initialisation de la matrice A sur la machine 0 et distribution par lignes
    if (rank == 0) {
        A = (double*) malloc(n * n * sizeof(double));
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                A[i*n+j] = rand() % 10;
            }
        }
        MPI_Scatter(A, p*n, MPI_DOUBLE, localA, p*n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
        free(A);
    } else {
        MPI_Scatter(NULL, p*n, MPI_DOUBLE, localA, p*n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
    }

    // Calcul de la trace locale
    localTrace = 0.0;
    for (i = 0; i < p; i++) {
        localTrace += localA[i*n+i];
    }

    // Réduction de la trace locale vers la machine 0
    MPI_Reduce(&localTrace, &globalTrace, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);

    // Affichage de la trace globale sur la machine 0
    if (rank == 0) {
        printf("Trace globale = %f\n", globalTrace);
    }

    free(localA);
    MPI_Finalize();

    return 0;
}

Explications :

- La machine de rang 0 lit la taille de la matrice et la diffuse à toutes les machines avec la fonction MPI_Bcast.
- Chaque machine calcule sa portion de la matrice A avec la fonction MPI_Scatter. La portion de la matrice est stockée dans un tableau localA de taille p x n.
- Chaque machine calcule sa trace locale en parcourant la diagonale de sa portion de la matrice.
- La trace locale est réduite vers la machine de rang 0 avec la fonction MPI_Reduce et l'opération MPI_SUM qui calcule la somme des traces locales.
- La machine de rang 0 affiche la trace globale.

Notez que nous avons choisi ici de distribuer la matrice par lignes. Il est également possible de la distribuer par colonnes ou par blocs. Le choix de la méthode de distribution dépend de la structure de la matrice et de l'algorithme utilisé.