structure DML_GATHER_ND1_OPERATOR_DESC (directml.h)

Collecte les éléments du tenseur d’entrée, à l’aide du tenseur d’index pour remappper les index sur des sous-blocs entiers de l’entrée. Cet opérateur effectue le pseudocode suivant, où « ... » représente une série de coordonnées, dont le comportement exact dépend du nombre de dimensions de lot, d’entrée et d’index.

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

Syntaxe

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

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 d’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 Tailles{1,4,5,2} avec IndexsDimensionCount = 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 index 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 tête IndexsTensor.Sizes et du segment de fin InputTensor.Sizes , qui donne ce qui suit.

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 sont alignées à droite, avec 1 valeurs principales ajoutées si nécessaire pour satisfaire 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 inputTensor après avoir ignoré toutes les principales non pertinentes, allant de [1, *InputTensor.DimensionCount*]. Par exemple, étant donné InputTensor.Sizes = {1,1,4,6} et InputDimensionCount = 3, les index significatifs réels sont {1,4,6}.

IndicesDimensionCount

Type : UINT

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

BatchDimensionCount

Type : UINT

Nombre de dimensions dans chaque tenseur (InputTensor, IndicesTensor, OutputTensor) qui sont considérées comme des lots indépendants, comprises à la fois dans [0, InputTensor.DimensionCount) et [0, IndicesTensor.DimensionCount). Le nombre de lots peut être 0, ce qui implique un seul lot. Par exemple, étant donné IndexSTensor.Sizes = {1,3,4,5,6,7} et IndexsDimensionCount = 5 et BatchDimensionCount = 2, il existe des lots et des {3,4} index {5,6,7}significatifs .

Notes

DML_GATHER_ND1_OPERATOR_DESC ajoute BatchDimensionCount et équivaut à DML_GATHER_ND_OPERATOR_DESC lorsque BatchDimensionCount = 0.

Exemples

Exemple 1. Remapping 1D

InputDimensionCount: 2
IndicesDimensionCount: 2
BatchDimensionCount: 0

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 avec le nombre de lots

InputDimensionCount: 3
IndicesDimensionCount: 3
BatchDimensionCount: 1

// 3 batches.
InputTensor: (Sizes:{1, 3,2,2}, DataType:FLOAT32)
    [
        [[[0,1],[2,3]],   // batch 0
         [[4,5],[6,7]],   // batch 1
         [[8,9],[10,11]]] // batch 2
    ]

// A 3x2 array of 2D tuples indexing into InputTensor.
// e.g. a tuple of <1,0> in batch 1 corresponds to input value 6.
IndicesTensor: (Sizes:{1, 3,2,2}, DataType:UINT32)
    [
        [[[0,0],[1,1]],
         [[1,1],[0,0]],
         [[0,1],[1,0]]]
    ]

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

Disponibilité

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

Contraintes tensoriels

• IndexsTensor, 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

Spécifications