Compartir a través de

estructura DML_SLICE1_OPERATOR_DESC (directml.h)

  • Artículo

Extrae una sola subregión (un "segmento") de un tensor de entrada.

La ventana de entrada describe los límites del tensor de entrada que se deben tener en cuenta en el segmento. La ventana se define con tres valores para cada dimensión.

  • El desplazamiento marca el principio de la ventana en una dimensión.
  • El tamaño marca la extensión de la ventana en una dimensión. El final de la ventana de una dimensión es offset + size - 1.
  • El paso indica cómo recorrer los elementos de una dimensión.
    • La magnitud del paso indica cuántos elementos se van a avanzar al copiar dentro de la ventana.
    • Si un paso es positivo, los elementos se copian a partir del principio de la ventana en la dimensión.
    • Si un paso es negativo, los elementos se copian a partir del final de la ventana en la dimensión.

El siguiente pseudocódigo ilustra cómo se copian los elementos mediante la ventana de entrada. Tenga en cuenta cómo se copian los elementos de una dimensión de principio a fin con un paso positivo y se copian de un extremo a otro con un paso 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]

La ventana de entrada no debe estar vacía en ninguna dimensión y la ventana no debe extenderse más allá de las dimensiones del tensor de entrada (no se permiten lecturas fuera de límite). El tamaño y los pasos de la ventana limitan eficazmente el número de elementos que se pueden copiar de cada dimensión i del tensor de entrada.

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

El tensor de salida no es necesario para copiar todos los elementos accesibles dentro de la ventana. El segmento es válido siempre que 1 <= OutputSizes[i] <= MaxCopiedElements[i].

Sintaxis

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

Miembros

InputTensor

Tipo: const DML_TENSOR_DESC*

Tensor del que se van a extraer segmentos.

OutputTensor

Tipo: const DML_TENSOR_DESC*

Tensor en el que se van a escribir los resultados de los datos segmentados.

DimensionCount

Tipo: UINT

Número de dimensiones. Este campo determina el tamaño de las matrices InputWindowOffsets, InputWindowSizes y InputWindowStrides . Este valor debe coincidir con dimensionCount de los tensores de entrada y salida. Este valor debe estar comprendido entre 1 y 8, inclusive, a partir de ; los niveles de DML_FEATURE_LEVEL_3_0características anteriores requieren un valor de 4 o 5.

InputWindowOffsets

Tipo: _Field_size_(DimensionCount) const UINT*

Matriz que contiene el principio (en elementos) de la ventana de entrada en cada dimensión. Los valores de la matriz deben satisfacer la restricción InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowSizes

Tipo: _Field_size_(DimensionCount) const UINT*

Matriz que contiene la extensión (en elementos) de la ventana de entrada en cada dimensión. Los valores de la matriz deben satisfacer la restricción InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowStrides

Tipo: _Field_size_(DimensionCount) const UINT*

Matriz que contiene el paso del segmento a lo largo de cada dimensión del tensor de entrada, en los elementos . La magnitud del paso indica cuántos elementos se van a avanzar al copiar dentro de la ventana de entrada. El signo del paso determina si los elementos se copian a partir del principio de la ventana (paso positivo) o el final de la ventana (paso negativo). Es posible que los pasos no sean 0.

Ejemplos

En los ejemplos siguientes se usa este mismo 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]]]]

Ejemplo 1. Segmento estridado con pasos 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]]]]

Los elementos copiados se calculan de la siguiente manera.

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

Ejemplo 2. Segmento estridado con pasos 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]]]]

Recuerde que las dimensiones con pasos de ventana negativos comienzan a copiarse al final de la ventana de entrada para esa dimensión; esto se hace agregando InputWindowSize[i] - 1 al desplazamiento de la ventana. Las dimensiones con un paso positivo simplemente comienzan en InputWindowOffset[i].

  • El eje 0 (+1 paso de ventana) comienza a copiar en InputWindowOffsets[0] = 0.
  • El eje 1 (+1 paso de ventana) comienza a copiar en InputWindowOffsets[1] = 0.
  • El eje 2 (-2 paso de ventana) comienza a copiar en InputWindowOffsets[2] + InputWindowSizes[0] - 1 = 0 + 4 - 1 = 3.
  • El eje 3 (+2 paso de ventana) comienza a copiar en InputWindowOffsets[3] = 1.

Los elementos copiados se calculan de la siguiente manera.

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

Comentarios

Este operador es similar a DML_SLICE_OPERATOR_DESC, pero difiere de dos maneras importantes.

  • Los pasos de segmento pueden ser negativos, lo que permite revertir los valores a lo largo de las dimensiones.
  • Los tamaños de ventana de entrada no son necesariamente los mismos que los tamaños de tensor de salida.

Disponibilidad

Este operador se introdujo en DML_FEATURE_LEVEL_2_1.

Restricciones tensor

InputTensor y OutputTensor deben tener el mismo DataType y DimensionCount.

Compatibilidad con Tensor

DML_FEATURE_LEVEL_4_1 y versiones posteriores

Tensor Clase Recuentos de dimensiones admitidos Tipos de datos admitidos
InputTensor Entrada De 1 a 8 FLOAT64, FLOAT32, FLOAT16, INT64, INT32, INT16, INT8, UINT64, UINT32, UINT16, UINT8
OutputTensor Resultados De 1 a 8 FLOAT64, FLOAT32, FLOAT16, INT64, INT32, INT16, INT8, UINT64, UINT32, UINT16, UINT8

DML_FEATURE_LEVEL_3_0 y versiones posteriores

Tensor Clase Recuentos de dimensiones admitidos Tipos de datos admitidos
InputTensor Entrada De 1 a 8 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8
OutputTensor Resultados De 1 a 8 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8

DML_FEATURE_LEVEL_2_1 y versiones posteriores

Tensor Clase Recuentos de dimensiones admitidos Tipos de datos admitidos
InputTensor Entrada De 4 a 5 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8
OutputTensor Resultados De 4 a 5 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8

Requisitos

Requisito Value
Cliente mínimo compatible compilación 20348 de Windows 10
Servidor mínimo compatible compilación 20348 de Windows 10
Encabezado directml.h