structure DML_GATHER_OPERATOR_DESC (directml.h)

Collecte les éléments du tenseur d’entrée le long de l’axe, à l’aide d’IndexsTensor pour remappper les index. Cet opérateur effectue le pseudocode suivant, où « ... » représente une série de coordonnées, avec le comportement exact déterminé par le nombre de dimensions d’axe et d’index :

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

Syntaxe

struct DML_GATHER_OPERATOR_DESC {
  const DML_TENSOR_DESC *InputTensor;
  const DML_TENSOR_DESC *IndicesTensor;
  const DML_TENSOR_DESC *OutputTensor;
  UINT                  Axis;
  UINT                  IndexDimensions;
};

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.

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 index négatifs sont interprétés comme étant relatifs à la fin de la dimension d’axe. Par exemple, un index de -1 fait référence au dernier élément le long de cette dimension.

Les index non valides produisent des sorties incorrectes, mais aucun échec ne se produit, et toutes les lectures sont bloquées en toute sécurité dans la mémoire du tenseur d’entrée.

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 et de fin InputTensor.Sizes fractionnés à l’axe actuel avec indexTensor.Sizes insérés entre.

OutputTensor.Sizes = {
    InputTensor.Sizes[0..Axis],
    IndicesTensor.Sizes[(IndicesTensor.DimensionCount - IndexDimensions) .. IndicesTensor.DimensionCount],
    InputTensor.Sizes[(Axis+1) .. InputTensor.DimensionCount]
}

Les dimensions sont alignées à droite de sorte que toutes les valeurs 1 principales des tailles d’entrée sont rognées, ce qui dépasserait le dimensionCount de sortie.

Le nombre de dimensions pertinentes dans ce tenseur dépend d’IndexDimensions et du rang d’origined’InputTensor. Le rang d’origine correspond au nombre de dimensions avant tout remplissage avec les premiers. Le nombre de dimensions pertinentes dans la sortie peut être calculé par le rang d’origined’InputTensor + IndexDimensions - 1. Cette valeur doit être inférieure ou égale à dimensionCount de OutputTensor.

Axis

Type : UINT

Dimension d’axe d’InputTensor sur laquelle se rassembler, allant de [0, *InputTensor.DimensionCount*).

IndexDimensions

Type : UINT

Nombre de dimensions d’index réelles dans le IndicesTensor après avoir ignoré toutes les principales non pertinentes, allant de [0, IndicesTensor.DimensionCount). Par exemple, étant donné IndicesTensor.Sizes = { 1, 1, 4, 6 } et IndexDimensions = 3, les index significatifs réels sont { 1, 4, 6 }.

Exemples

Exemple 1. Remapping 1D

Axis: 0
IndexDimensions: 1

InputTensor: (Sizes:{4}, DataType:FLOAT32)
    [11,12,13,14]

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

// output[x] = input[indices[x]]
OutputTensor: (Sizes:{5}, DataType:FLOAT32)
    [14,12,14,11,13]

Exemple 2. Sortie 2D, index 1D, axe 0, lignes concaténées

Axis: 0
IndexDimensions: 1

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

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

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

Exemple 3. 2D, Axe 1, permutation de colonnes

Axis: 1
IndexDimensions: 2

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

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

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

Exemple 4. 2D, Axe 1, index imbriqués

Axis: 2
IndexDimensions: 2

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

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

// output[z, y, x] = input[z, indices[y, x]]
OutputTensor: (Sizes:{3,1,2}, DataType:FLOAT32)
    [[[1,3]],
     [[4,6]],
     [[7,9]]]

Exemple 5. 2D, Axe 0, index imbriqués

Axis: 1
IndexDimensions: 2

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

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

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

Disponibilité

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

Contraintes tensoriels

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

Prise en charge de Tensor

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

DML_FEATURE_LEVEL_1_0 et versions ultérieures

Configuration requise