estrutura DML_GATHER_ND1_OPERATOR_DESC (directml.h)

Coleta elementos do tensor de entrada, usando o tensor de índices para remapear índices para subblocos inteiros da entrada. Esse operador executa o pseudocódigo a seguir, em que "..." representa uma série de coordenadas, com o comportamento exato dependente da contagem de dimensões de lote, entrada e índices.

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

Sintaxe

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;
};

Membros

InputTensor

Tipo: const DML_TENSOR_DESC*

O tensor do qual ler.

IndicesTensor

Tipo: const DML_TENSOR_DESC*

O tensor que contém os índices. O DimensionCount deste tensor deve corresponder a InputTensor.DimensionCount. A última dimensão do IndicesTensor é, na verdade, o número de coordenadas por tupla de índice e não pode exceder InputTensor.DimensionCount. Por exemplo, um tensor de índices de Tamanhos{1,4,5,2} com IndicesDimensionCount = 3 significa uma matriz 4x5 de tuplas de duas coordenadas que indexam em InputTensor.

DML_FEATURE_LEVEL_3_0A partir do , esse operador dá suporte a valores de índice negativos ao usar um tipo integral assinado com esse tensor. Índices negativos são interpretados como sendo relativos ao final da respectiva dimensão. Por exemplo, um índice de -1 refere-se ao último elemento nessa dimensão.

OutputTensor

Tipo: const DML_TENSOR_DESC*

O tensor no qual gravar os resultados. O DimensionCount e o DataType deste tensor devem corresponder a InputTensor.DimensionCount. Os OutputTensor.Sizes esperados são a concatenação dos segmentos à esquerda IndicesTensor.Sizes e InputTensor.Sizes à direita, o que produz o seguinte.

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

As dimensões são alinhadas à direita, com 1 valores à esquerda anexados, se necessário, para satisfazer OutputTensor.DimensionCount.

Veja um exemplo.

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

Tipo: UINT

O número de dimensões de entrada reais no InputTensor depois de ignorar as irrelevantes à esquerda, variando [1, *InputTensor.DimensionCount*]. Por exemplo, dado InputTensor.Sizes = {1,1,4,6} e InputDimensionCount = 3, os índices significativos reais são {1,4,6}.

IndicesDimensionCount

Tipo: UINT

O número de dimensões de índice reais no IndicesTensor depois de ignorar quaisquer irrelevantes à esquerda, variando [1, IndicesTensor.DimensionCount]. Por exemplo, considerando IndicesTensor.Sizes = {1,1,4,6} e IndicesDimensionCount = 3, os índices significativos reais são {1,4,6}.

BatchDimensionCount

Tipo: UINT

O número de dimensões dentro de cada tensor (InputTensor, IndicesTensor, OutputTensor) que são consideradas lotes independentes, variando dentro de [0, InputTensor.DimensionCount) e [0, IndicesTensor.DimensionCount). A contagem de lotes pode ser 0, implicando um único lote. Por exemplo, considerando IndicesTensor.Sizes = {1,3,4,5,6,7} e IndicesDimensionCount = 5 e BatchDimensionCount = 2, há lotes {3,4} e índices significativos {5,6,7}.

Comentários

DML_GATHER_ND1_OPERATOR_DESC adiciona BatchDimensionCount e é equivalente a DML_GATHER_ND_OPERATOR_DESC quando BatchDimensionCount = 0.

Exemplos

Exemplo 1. Remapeamento 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]]

Exemplo 2. Remapeamento 2D com contagem de lotes

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]]
    ]]

Disponibilidade

Esse operador foi introduzido no DML_FEATURE_LEVEL_3_0.

Restrições do Tensor

• IndicesTensor, InputTensor e OutputTensor devem ter o mesmo DimensionCount.
• InputTensor e OutputTensor devem ter o mesmo DataType.

Suporte ao Tensor

DML_FEATURE_LEVEL_4_1 e superior

DML_FEATURE_LEVEL_3_0 e superior

Requisitos