structure DML_SLICE1_OPERATOR_DESC (directml.h)

Extrait une sous-région unique (une « tranche ») d’un tenseur d’entrée.

La fenêtre d’entrée décrit les limites du tenseur d’entrée à prendre en compte dans la tranche. La fenêtre est définie à l’aide de trois valeurs pour chaque dimension.

• Le décalage marque le début de la fenêtre dans une dimension.
• La taille marque l’étendue de la fenêtre dans une dimension. La fin de la fenêtre dans une dimension est offset + size - 1.
• La foulée indique comment parcourir les éléments d’une dimension.
  • L’ampleur de la foulée indique le nombre d’éléments à avancer lors de la copie dans la fenêtre.
  • Si une foulée est positive, les éléments sont copiés en commençant au début de la fenêtre dans la dimension.
  • Si une foulée est négative, les éléments sont copiés en commençant à la fin de la fenêtre dans la dimension.

Le pseudo-code suivant illustre la façon dont les éléments sont copiés à l’aide de la fenêtre d’entrée. Notez comment les éléments d’une dimension sont copiés du début à la fin avec une foulée positive et copiés de bout en début avec une foulée négative.

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 fenêtre d’entrée ne doit pas être vide dans une dimension et la fenêtre ne doit pas s’étendre au-delà des dimensions du tenseur d’entrée (les lectures hors limites ne sont pas autorisées). La taille et les foulées de la fenêtre limitent efficacement le nombre d’éléments pouvant être copiés à partir de chaque dimension i du tenseur d’entrée.

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

Le tenseur de sortie n’est pas nécessaire pour copier tous les éléments accessibles dans la fenêtre. La tranche est valide tant que 1 <= OutputSizes[i] <= MaxCopiedElements[i].

Syntaxe

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

Membres

InputTensor

Type : const DML_TENSOR_DESC*

Tenseur à partir duquel extraire des tranches.

OutputTensor

Type : const DML_TENSOR_DESC*

Tenseur dans lequel écrire les résultats des données segmentées.

DimensionCount

Type : UINT

Nombre de dimensions. Ce champ détermine la taille des tableaux InputWindowOffsets, InputWindowSizes et InputWindowStrides . Cette valeur doit correspondre au DimensionCount des tenseurs d’entrée et de sortie. Cette valeur doit être comprise entre 1 et 8, inclusivement, à partir de DML_FEATURE_LEVEL_3_0; les niveaux de fonctionnalités antérieurs nécessitent une valeur de 4 ou 5.

InputWindowOffsets

Type : _Field_size_(DimensionCount) const UINT*

Tableau contenant le début (en éléments) de la fenêtre d’entrée dans chaque dimension. Les valeurs du tableau doivent satisfaire à la contrainte InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowSizes

Type : _Field_size_(DimensionCount) const UINT*

Tableau contenant l’étendue (en éléments) de la fenêtre d’entrée dans chaque dimension. Les valeurs du tableau doivent satisfaire à la contrainte InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowStrides

Type : _Field_size_(DimensionCount) const UINT*

Tableau contenant la foulée de la tranche le long de chaque dimension du tenseur d’entrée, dans des éléments. L’ampleur de la foulée indique le nombre d’éléments à avancer lors de la copie dans la fenêtre d’entrée. Le signe de la foulée détermine si les éléments sont copiés en commençant au début de la fenêtre (foulée positive) ou à la fin de la fenêtre (pas négatif). Les foulées peuvent ne pas être 0.

Exemples

Les exemples suivants utilisent ce même tenseur d’entrée.

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

Exemple 1. Tranche enjambée avec des foulées positives

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

Les éléments copiés sont calculés comme suit.

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

Exemple 2. Segment à foulées avec des foulées négatives

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

Rappelez-vous que les dimensions avec des foulées de fenêtre négatives commencent à copier à la fin de la fenêtre d’entrée pour cette dimension ; pour ce faire, ajoutez InputWindowSize[i] - 1 au décalage de fenêtre. Les dimensions avec une foulée positive commencent simplement à InputWindowOffset[i].

• L’axe 0 (+1 foulée de fenêtre) commence la copie à InputWindowOffsets[0] = 0.
• L’axe 1 (+1 foulée de fenêtre) commence la copie à InputWindowOffsets[1] = 0.
• L’axe 2 (-2 foulée de fenêtre) commence la copie à l’emplacement InputWindowOffsets[2] + InputWindowSizes[0] - 1 = 0 + 4 - 1 = 3.
• L’axe 3 (+2 foulée de fenêtre) commence la copie à InputWindowOffsets[3] = 1.

Les éléments copiés sont calculés comme suit.

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

Remarques

Cet opérateur est similaire à DML_SLICE_OPERATOR_DESC, mais il diffère de deux manières importantes.

• Les foulées de tranche peuvent être négatives, ce qui permet d’inverser les valeurs le long des dimensions.
• Les tailles de fenêtre d’entrée ne sont pas nécessairement identiques à celles des tenseurs de sortie.

Disponibilité

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

Contraintes tensoriels

InputTensor et OutputTensor doivent avoir les mêmes DataType et DimensionCount.

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

Configuration requise