Fonction torch.scatter_reduce de PyTorch

Pytorch torch 参考手册Manuel de référence PyTorch torch

torch.scatter_reduceC'est une fonction dans PyTorch utilisée pour agréger les valeurs d'un tenseur source à des positions spécifiées d'une manière spécifiée. Elle prend en charge plusieurs méthodes d'agrégation, telles que sum, product, max, min, etc.

Définition de fonction

torch.scatter_reduce(input, dim, index, src, reduce='sum', *, include_self=True)

Parameters:

  • input(Tensor) : Le tenseur d'entrée.
  • dim(int) : La dimension selon laquelle agréger.
  • index(Tensor) : Le tenseur d'indices, spécifiant où agréger les valeurs de src dans input.
  • src(Tensor) : Le tenseur source, les valeurs à agréger.
  • reduce(str) : La méthode d'agrégation. Les options sont 'sum', 'prod', 'mean', 'amax', 'amin', 'multiply'. La valeur par défaut est 'sum'.
  • include_self(bool, optional) : Indique si la valeur d'origine à la position d'index elle-même doit être incluse dans l'agrégation. La valeur par défaut est True.

Valeur de retour:

  • torch.Tensor: Renvoie le tenseur agrégé.

Exemples d'utilisation

Exemple

import torch

# Créer un tenseur d'entrée
input = torch.ones(3, 5)

# Créer l'index et la source
index = torch.tensor([[0, 1, 2, 0, 0],
                      [1, 2, 0, 1, 2],
                      [2, 0, 1, 2, 0]])
src = torch.tensor([[1, 1, 1, 1, 1],
                    [2, 2, 2, 2, 2],
                    [3, 3, 3, 3, 3]])

# Utiliser l'agrégation sum
output = torch.scatter_reduce(input, dim=0, index=index, src=src, reduce='sum')

print("Entrée :")
print(input)
print("nAggregation method: sum")
print("Résultat :")
print(output)

Le résultat de sortie est:

输入:
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])

聚合方式: sum
结果:
tensor([[4., 2., 3., 4., 4.],
        [2., 2., 2., 2., 2.],
        [3., 3., 2., 3., 3.]])

Exemple

import torch

# Tester différentes méthodes d'agrégation
input = torch.zeros(3, 3)
index = torch.tensor([[0, 0, 0],
                      [1, 1, 1],
                      [2, 2, 2]])
src = torch.tensor([[2, 3, 4],
                    [5, 6, 7],
                    [8, 9, 10]])

# Utiliser prod (produit)
output_prod = torch.scatter_reduce(input, 0, index, src, reduce='prod')
print("agrégation prod :")
print(output_prod)

# Utiliser amax (maximum)
output_max = torch.scatter_reduce(input, 0, index, src, reduce='amax')
print("namax agrégation :")
print(output_max)

# Utiliser amin (minimum)
output_min = torch.scatter_reduce(input, 0, index, src, reduce='amin')
print("agrégation namin:")
print(output_min)

Le résultat de sortie est:

prod 聚合:
tensor([[ 2.,  3.,  4.],
        [ 5.,  6.,  7.],
        [ 8.,  9., 10.]])

amax 聚合:
tensor([[ 2.,  3.,  4.],
        [ 5.,  6.,  7.],
        [ 8.,  9., 10.]])

amin 聚合:
tensor([[ 2.,  3.,  4.],
        [ 5.,  6.,  7.],
        [ 8.,  9., 10.]])

Exemple

import torch

# Utiliser le paramètre include_self
input = torch.tensor([1.0, 2.0, 3.0])
index = torch.tensor([0, 0, 0])
src = torch.tensor([10.0, 20.0, 30.0])

# Inclure la valeur self (par défaut)
output1 = torch.scatter_reduce(input, 0, index, src, reduce='sum', include_self=True)
print("include_self=True:", output1)

# Exclure la valeur self
output2 = torch.scatter_reduce(input, 0, index, src, reduce='sum', include_self=False)
print("include_self=False:", output2)

Le résultat de sortie est:

include_self=True: tensor([66.,  2.,  3.])
include_self=False: tensor([60.,  2.,  3.])

Remarque :torch.scatter_reduceIl ne modifie pas le tenseur d'entrée d'origine, mais renvoie un nouveau tenseur. Plusieurs indices peuvent pointer vers la même position, et les valeurs seront agrégées selon la méthode d'agrégation spécifiée.include_self=FalseIl est utile dans certains scénarios, par exemple pour éviter le calcul répété des caractéristiques propres d'un nœud dans les réseaux neuronaux de graphes.

Pytorch torch 参考手册Manuel de référence PyTorch torch

Autres extensions