DML_GATHER_ND_OPERATOR_DESC structure (directml.h)

Collecte les éléments du tenseur d’entrée, en utilisant le tenseur d’index pour remapper les index sur des sous-blocs entiers de l’entrée. Cet opérateur exécute le pseudocode suivant, où « ... » représente une série de coordonnées, avec le comportement exact dépendant du nombre de dimensions d’entrée et d’index.

output[...] = input[indices[...]]

Syntaxe

struct DML_GATHER_ND_OPERATOR_DESC {
  const DML_TENSOR_DESC *InputTensor;
  const DML_TENSOR_DESC *IndicesTensor;
  const DML_TENSOR_DESC *OutputTensor;
  UINT                  InputDimensionCount;
  UINT                  IndicesDimensionCount;
};

Membres

InputTensor

Type : const DML_TENSOR_DESC*

Tenseur à partir duquel lire.

IndicesTensor

Type : const DML_TENSOR_DESC*

Tenseur contenant les index. Le DimensionCount de ce tenseur doit correspondre à InputTensor.DimensionCount. La dernière dimension de IndexsTensor est en fait le nombre de coordonnées par tuple d’index, et elle ne peut pas dépasser InputTensor.DimensionCount. Par exemple, un tenseur d’index de Sizes{1,4,5,2} avec IndicesDimensionCount = 3 signifie un tableau 4x5 de tuples à 2 coordonnées qui s’indexent dans InputTensor.

DML_FEATURE_LEVEL_3_0À compter de , cet opérateur prend en charge les valeurs d’index négatives lors de l’utilisation d’un type intégral signé avec ce tenseur. Les indices négatifs sont interprétés comme étant relatifs à la fin de la dimension respective. Par exemple, un index de -1 fait référence au dernier élément le long de cette dimension.

OutputTensor

Type : const DML_TENSOR_DESC*

Tenseur dans lequel écrire les résultats. DimensionCount et DataType de ce tenseur doivent correspondre à InputTensor.DimensionCount. Les outputTensor.Sizes attendus sont la concaténation des segments de début IndicesTensor.Sizes et du segment de fin InputTensor.Sizes pour produire :

indexTupleSize = IndicesTensor.Sizes[IndicesTensor.DimensionCount - 1]
OutputTensor.Sizes = {
    1...,
    IndicesTensor.Sizes[(IndicesTensor.DimensionCount - IndicesDimensionCount) .. (IndicesTensor.DimensionCount - 1)],
    InputTensor.Sizes[(InputTensor.DimensionCount - indexTupleSize) .. InputTensor.DimensionCount]
}

Les dimensions de sortie sont alignées à droite, avec 1 valeur de début ajoutée si nécessaire pour satisfaire jusqu’à OutputTensor.DimensionCount.

Voici un exemple.

InputTensor.Sizes = {3,4,5,6,7}
InputDimensionCount = 5
IndicesTensor.Sizes = {1,1, 1,2,3}
IndicesDimensionCount = 3 // can be thought of as a {1,2} array of 3-coordinate tuples

// The {1,2} comes from the indices tensor (ignoring last dimension which is the tuple size),
// and the {6,7} comes from input tensor, ignoring the first 3 dimensions
// since the index tuples are 3 elements (from the indices tensor last dimension).
OutputTensor.Sizes = {1, 1,2,6,7}

InputDimensionCount

Type : UINT

Nombre de dimensions d’entrée réelles dans le InputTensor après avoir ignoré toutes les dimensions d’entrée non pertinentes, allant de [1, *InputTensor.DimensionCount*]. Par exemple, étant donné InputTensor.Sizes = {1,1,4,6} et InputDimensionCount = 3, les indices significatifs réels sont {1,4,6}.

IndicesDimensionCount

Type : UINT

Nombre de dimensions d’index réelles au sein du IndexsTensor après avoir ignoré toutes les dimensions de début non pertinentes, allant de [1, IndicesTensor.DimensionCount]. Par exemple, étant donné IndexsTensor.Sizes = {1,1,4,6} et IndicesDimensionCount = 3, les indices significatifs réels sont {1,4,6}.

Exemples

Exemple 1. Remapping 1D

InputDimensionCount: 2
IndicesDimensionCount: 2

InputTensor: (Sizes:{2,2}, DataType:FLOAT32)
    [[0,1],[2,3]]

IndicesTensor: (Sizes:{2,1}, DataType:UINT32)
    [[1],[0]]

// output[y, x] = input[indices[y], x]
OutputTensor: (Sizes:{2,2}, DataType:FLOAT32)
    [[2,3],[0,1]]

Exemple 2. Remapping 2D

InputDimensionCount: 3
IndicesDimensionCount: 2

InputTensor: (Sizes:{1, 2,2,2}, DataType:FLOAT32)
    [ [[[0,1],[2,3]],[[4,5],[6,7]]] ]

IndicesTensor: (Sizes:{1,1, 2,2}, DataType:UINT32)
    [[ [[0,1],[1,0]] ]]

// output[y, x] = input[indices[y, 0], indices[y, 1], x]
OutputTensor: (Sizes:{1,1, 2,2}, DataType:FLOAT32)
    [[ [[2,3],[4,5]] ]]

Remarques

Une version plus récente de cet opérateur, DML_OPERATOR_GATHER_ND1, a été introduite dans DML_FEATURE_LEVEL_3_0.

Disponibilité

Cet opérateur a été introduit dans DML_FEATURE_LEVEL_2_1.

Contraintes tensoriels

• IndexsTensor, InputTensor et OutputTensor doivent avoir le même DimensionCount.
• InputTensor et OutputTensor doivent avoir le même DataType.

Prise en charge des tenseurs

DML_FEATURE_LEVEL_4_1 et versions ultérieures

DML_FEATURE_LEVEL_3_0 et versions ultérieures

DML_FEATURE_LEVEL_2_1 et versions ultérieures

Configuration requise