struttura DML_SLICE1_OPERATOR_DESC (directml.h)

Estrae una singola sottoregione (una "sezione") di un tensore di input.

La finestra di input descrive i limiti del tensore di input da considerare nella sezione. La finestra viene definita usando tre valori per ogni dimensione.

• L'offset contrassegna l'inizio della finestra in una dimensione.
• La dimensione contrassegna l'extent della finestra in una dimensione. La fine della finestra in una dimensione è offset + size - 1.
• Lo stride indica come attraversare gli elementi in una dimensione.
  • La grandezza dello stride indica il numero di elementi da avanzare durante la copia all'interno della finestra.
  • Se uno stride è positivo, gli elementi vengono copiati a partire dall'inizio della finestra nella dimensione.
  • Se uno stride è negativo, gli elementi vengono copiati a partire dalla fine della finestra nella dimensione.

Lo pseudo-codice seguente illustra il modo in cui gli elementi vengono copiati usando la finestra di input. Si noti che gli elementi in una dimensione vengono copiati dall'inizio alla fine con uno stride positivo e copiati dalla fine all'inizio con uno stride 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 finestra di input non deve essere vuota in alcuna dimensione e la finestra non deve estendersi oltre le dimensioni del tensore di input (le letture non consentite). Le dimensioni e i progressi della finestra limitano in modo efficace il numero di elementi che possono essere copiati da ogni dimensione i del tensore di input.

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

Il tensore di output non è necessario per copiare tutti gli elementi raggiungibili all'interno della finestra. La sezione è valida fino a 1 <= OutputSizes[i] <= MaxCopiedElements[i]quando .

Sintassi

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

Members

InputTensor

Tipo: const DML_TENSOR_DESC*

Tensore da cui estrarre le sezioni.

OutputTensor

Tipo: const DML_TENSOR_DESC*

Tensore in cui scrivere i risultati dei dati sezionati.

DimensionCount

Tipo: UINT

Numero di dimensioni. Questo campo determina le dimensioni delle matrici InputWindowOffsets, InputWindowSizes e InputWindowStrides . Questo valore deve corrispondere al Valore DimensionCount dei tensori di input e output. Questo valore deve essere compreso tra 1 e 8, inclusi, a partire da DML_FEATURE_LEVEL_3_0. I livelli di funzionalità precedenti richiedono un valore pari a 4 o 5.

InputWindowOffsets

Tipo: _Field_size_(DimensionCount) const UINT*

Matrice contenente l'inizio (in elementi) della finestra di input in ogni dimensione. I valori nella matrice devono soddisfare il vincolo InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowSizes

Tipo: _Field_size_(DimensionCount) const UINT*

Matrice contenente l'extent (in elementi) della finestra di input in ogni dimensione. I valori nella matrice devono soddisfare il vincolo InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowStrides

Tipo: _Field_size_(DimensionCount) const UINT*

Matrice contenente lo stride della sezione lungo ogni dimensione del tensore di input, negli elementi . La grandezza dello stride indica il numero di elementi da avanzare durante la copia all'interno della finestra di input. Il segno dello stride determina se gli elementi vengono copiati a partire dall'inizio della finestra (stride positivo) o dalla fine della finestra (stride negativa). I progressi potrebbero non essere 0.

Esempio

Negli esempi seguenti viene usato lo stesso tensore di input.

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

Esempio 1. Strided slice con passi positivi

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

Gli elementi copiati vengono calcolati come segue.

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

Esempio 2. Strided slice con passi negativi

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

Tenere presente che le dimensioni con passi negativi della finestra iniziano a copiare alla fine della finestra di input per tale dimensione; questa operazione viene eseguita aggiungendo InputWindowSize[i] - 1 all'offset della finestra. Le dimensioni con uno stride positivo iniziano semplicemente da InputWindowOffset[i].

• L'asse 0 (+1 stride della finestra) inizia a copiare in corrispondenza di InputWindowOffsets[0] = 0.
• L'asse 1 (+1 stride della finestra) inizia a copiare in corrispondenza di InputWindowOffsets[1] = 0.
• L'asse 2 (-2 stride della finestra) inizia a copiare in corrispondenza di InputWindowOffsets[2] + InputWindowSizes[0] - 1 = 0 + 4 - 1 = 3.
• L'asse 3 (+2 stride della finestra) inizia a copiare in corrispondenza di InputWindowOffsets[3] = 1.

Gli elementi copiati vengono calcolati come segue.

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

Commenti

Questo operatore è simile a DML_SLICE_OPERATOR_DESC, ma differisce in due modi importanti.

• I passi delle sezioni possono essere negativi, che consentono di ripristinare i valori lungo le dimensioni.
• Le dimensioni della finestra di input non corrispondono necessariamente alle dimensioni del tensore di output.

Disponibilità

Questo operatore è stato introdotto in DML_FEATURE_LEVEL_2_1.

Vincoli tensor

InputTensor e OutputTensor devono avere lo stesso Tipo di dati e DimensionCount.

Supporto di Tensor

DML_FEATURE_LEVEL_4_1 e versioni successive

DML_FEATURE_LEVEL_3_0 e versioni successive

DML_FEATURE_LEVEL_2_1 e versioni successive

Requisiti