Compartilhar via

estrutura DML_SLICE1_OPERATOR_DESC (directml.h)

  • Artigo

Extrai uma única sub-região (uma "fatia") de um tensor de entrada.

A janela de entrada descreve os limites do tensor de entrada a ser considerado na fatia. A janela é definida usando três valores para cada dimensão.

  • O deslocamento marca o início da janela em uma dimensão.
  • O tamanho marca a extensão da janela em uma dimensão. O final da janela em uma dimensão é offset + size - 1.
  • O passo indica como percorrer os elementos em uma dimensão.
    • A magnitude do passo indica quantos elementos avançar ao copiar dentro da janela.
    • Se um passo for positivo, os elementos serão copiados começando no início da janela na dimensão.
    • Se um passo for negativo, os elementos serão copiados começando no final da janela na dimensão.

O pseudocódigo a seguir ilustra como os elementos são copiados usando a janela de entrada. Observe como os elementos em uma dimensão são copiados do início ao fim com um passo positivo e copiados de ponta a ponta com um passo negativo.

CopyStart = InputWindowOffsets
for dimension i in [0, DimensionCount - 1]:
    if InputWindowStrides[i] < 0:
        CopyStart[i] += InputWindowSizes[i] - 1 // start at the end of the window in this dimension

OutputTensor[OutputCoordinates] = InputTensor[CopyStart + InputWindowStrides * OutputCoordinates]

A janela de entrada não deve estar vazia em nenhuma dimensão e a janela não deve se estender além das dimensões do tensor de entrada (leituras fora dos limites não são permitidas). O tamanho e os passos da janela limitam efetivamente o número de elementos que podem ser copiados de cada dimensão i do tensor de entrada.

MaxCopiedElements[i] = 1 + (InputWindowSize[i] - 1) / InputWindowStrides[i]

O tensor de saída não é necessário para copiar todos os elementos acessíveis dentro da janela. A fatia é válida desde 1 <= OutputSizes[i] <= MaxCopiedElements[i]que .

Sintaxe

struct DML_SLICE1_OPERATOR_DESC {
  const DML_TENSOR_DESC *InputTensor;
  const DML_TENSOR_DESC *OutputTensor;
  UINT                  DimensionCount;
  const UINT            *InputWindowOffsets;
  const UINT            *InputWindowSizes;
  const INT             *InputWindowStrides;
};

Membros

InputTensor

Tipo: const DML_TENSOR_DESC*

O tensor do qual extrair fatias.

OutputTensor

Tipo: const DML_TENSOR_DESC*

O tensor no qual gravar os resultados dos dados fatiados.

DimensionCount

Tipo: UINT

O número de dimensões. Esse campo determina o tamanho das matrizes InputWindowOffsets, InputWindowSizes e InputWindowStrides . Esse valor deve corresponder ao DimensionCount dos tensores de entrada e saída. Esse valor deve estar entre 1 e 8, inclusive, a partir de DML_FEATURE_LEVEL_3_0; os níveis de recursos anteriores exigem um valor de 4 ou 5.

InputWindowOffsets

Tipo: _Field_size_(DimensionCount) const UINT*

Uma matriz que contém o início (em elementos) da janela de entrada em cada dimensão. Os valores na matriz devem atender à restrição InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowSizes

Tipo: _Field_size_(DimensionCount) const UINT*

Uma matriz que contém a extensão (em elementos) da janela de entrada em cada dimensão. Os valores na matriz devem atender à restrição InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowStrides

Tipo: _Field_size_(DimensionCount) const UINT*

Uma matriz que contém o passo da fatia ao longo de cada dimensão do tensor de entrada, em elementos . A magnitude do passo indica quantos elementos avançar ao copiar dentro da janela de entrada. O sinal do passo determina se os elementos são copiados começando no início da janela (avanço positivo) ou no final da janela (passo negativo). Os passos podem não ser 0.

Exemplos

Os exemplos a seguir usam esse mesmo tensor de entrada.

InputTensor: (Sizes:{1, 1, 4, 4}, DataType:FLOAT32)
[[[[ 1,  2,  3,  4],
   [ 5,  6,  7,  8],
   [ 9, 10, 11, 12],
   [13, 14, 15, 16]]]]

Exemplo 1. Fatia estridente com avanços positivos

InputWindowOffsets = {0, 0, 0, 1}
InputWindowSizes   = {1, 1, 4, 3}
InputWindowStrides = {1, 1, 2, 2}

OutputTensor: (Sizes:{1, 1, 2, 2}, DataType:FLOAT32)
[[[[ 2,  4],
   [10, 12]]]]

Os elementos copiados são calculados da seguinte maneira.

Output[0,0,0,0] = {0,0,0,1} + {1,1,2,2} * {0,0,0,0} = Input[{0,0,0,1}] = 2
Output[0,0,0,1] = {0,0,0,1} + {1,1,2,2} * {0,0,0,1} = Input[{0,0,0,3}] = 4
Output[0,0,1,0] = {0,0,0,1} + {1,1,2,2} * {0,0,1,0} = Input[{0,0,2,1}] = 10
Output[0,0,1,1] = {0,0,0,1} + {1,1,2,2} * {0,0,1,1} = Input[{0,0,2,3}] = 12

Exemplo 2. Fatia estridente com avanços negativos

InputWindowOffsets = {0, 0, 0, 1}
InputWindowSizes   = {1, 1, 4, 3}
InputWindowStrides = {1, 1, -2, 2}

OutputTensor: (Sizes:{1, 1, 2, 2}, DataType:FLOAT32)
[[[[14, 16],
   [ 6,  8]]]]

Lembre-se de que dimensões com avanços negativos da janela começam a ser copiadas no final da janela de entrada para essa dimensão; isso é feito adicionando InputWindowSize[i] - 1 ao deslocamento da janela. Dimensões com um passo positivo simplesmente começam em InputWindowOffset[i].

  • O eixo 0 (+1 passo da janela) começa a copiar em InputWindowOffsets[0] = 0.
  • O Eixo 1 ( passo+1 da janela) começa a copiar em InputWindowOffsets[1] = 0.
  • O eixo 2 (-2 passo da janela) começa a copiar em InputWindowOffsets[2] + InputWindowSizes[0] - 1 = 0 + 4 - 1 = 3.
  • O Eixo 3 ( passo+2 da janela) começa a copiar em InputWindowOffsets[3] = 1.

Os elementos copiados são calculados da seguinte maneira.

Output[0,0,0,0] = {0,0,3,1} + {1,1,-2,2} * {0,0,0,0} = Input[{0,0,3,1}] = 14
Output[0,0,0,1] = {0,0,3,1} + {1,1,-2,2} * {0,0,0,1} = Input[{0,0,3,3}] = 16
Output[0,0,1,0] = {0,0,3,1} + {1,1,-2,2} * {0,0,1,0} = Input[{0,0,1,1}] = 6
Output[0,0,1,1] = {0,0,3,1} + {1,1,-2,2} * {0,0,1,1} = Input[{0,0,1,3}] = 8

Comentários

Esse operador é semelhante a DML_SLICE_OPERATOR_DESC, mas é diferente de duas maneiras importantes.

  • Os passos de fatia podem ser negativos, o que permite reverter valores ao longo das dimensões.
  • Os tamanhos da janela de entrada não são necessariamente os mesmos que os tamanhos de tensor de saída.

Disponibilidade

Esse operador foi introduzido no DML_FEATURE_LEVEL_2_1.

Restrições do Tensor

InputTensor e OutputTensor devem ter os mesmos DataType e DimensionCount.

Suporte ao Tensor

DML_FEATURE_LEVEL_4_1 e superior

Tensor Tipo Contagens de dimensões com suporte Tipos de dados com suporte
InputTensor Entrada 1 a 8 FLOAT64, FLOAT32, FLOAT16, INT64, INT32, INT16, INT8, UINT64, UINT32, UINT16, UINT8
OutputTensor Saída 1 a 8 FLOAT64, FLOAT32, FLOAT16, INT64, INT32, INT16, INT8, UINT64, UINT32, UINT16, UINT8

DML_FEATURE_LEVEL_3_0 e superior

Tensor Tipo Contagens de dimensões com suporte Tipos de dados com suporte
InputTensor Entrada 1 a 8 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8
OutputTensor Saída 1 a 8 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8

DML_FEATURE_LEVEL_2_1 e superior

Tensor Tipo Contagens de dimensões com suporte Tipos de dados com suporte
InputTensor Entrada 4 a 5 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8
OutputTensor Saída 4 a 5 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8

Requisitos

Requisito Valor
Cliente mínimo com suporte Windows 10 Build 20348
Servidor mínimo com suporte Windows 10 Build 20348
Cabeçalho directml.h