Freigeben über

DML_SLICE1_OPERATOR_DESC-Struktur (directml.h)

  • Artikel

Extrahiert einen einzelnen Unterbereich (ein "Slice") eines Eingabe tensors.

Das Eingabefenster beschreibt die Grenzen des Eingabe tensors, der im Slice berücksichtigt werden soll. Das Fenster wird mit drei Werten für jede Dimension definiert.

  • Der Offset markiert den Anfang des Fensters in einer Dimension.
  • Die Größe markiert die Ausdehnung des Fensters in einer Dimension. Das Ende des Fensters in einer Dimension ist offset + size - 1.
  • Die Stride gibt an, wie die Elemente in einer Dimension durchlaufen werden.
    • Die Größe der Stride gibt an, wie viele Elemente beim Kopieren innerhalb des Fensters erweitert werden sollen.
    • Wenn ein Stride positiv ist, werden Elemente ab dem Anfang des Fensters in der Dimension kopiert.
    • Wenn ein Schritt negativ ist, werden Elemente ab dem Ende des Fensters in der Dimension kopiert.

Der folgende Pseudocode veranschaulicht, wie Elemente mithilfe des Eingabefensters kopiert werden. Beachten Sie, wie Elemente in einer Dimension von Anfang bis Ende mit einem positiven Schritt kopiert und von Ende bis Anfang mit einem negativen Schritt kopiert werden.

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]

Das Eingabefenster darf in keiner Dimension leer sein, und das Fenster darf nicht über die Dimensionen des Eingabe tensors hinausgehen (Lesevorgänge außerhalb der Grenzen sind nicht zulässig). Die Größe und die Schritte des Fensters begrenzen effektiv die Anzahl der Elemente, die aus jeder Dimension i des Eingabe tensors kopiert werden können.

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

Der Ausgabe tensor ist nicht erforderlich, um alle erreichbaren Elemente innerhalb des Fensters zu kopieren. Der Slice ist gültig, solange .1 <= OutputSizes[i] <= MaxCopiedElements[i]

Syntax

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

Member

InputTensor

Typ: const DML_TENSOR_DESC*

Der Tensor, aus dem Slices extrahiert werden sollen.

OutputTensor

Typ: const DML_TENSOR_DESC*

Der Tensor, in den die Datenschnitte geschrieben werden sollen.

DimensionCount

Typ: UINT

Die Anzahl der Dimensionen. Dieses Feld bestimmt die Größe der Arrays InputWindowOffsets, InputWindowSizes und InputWindowStrides . Dieser Wert muss mit dem DimensionCount der Eingabe- und Ausgabe tensors übereinstimmen. Dieser Wert muss ab zwischen 1 und 8 liegen. DML_FEATURE_LEVEL_3_0Frühere Featureebenen erfordern einen Wert von 4 oder 5.

InputWindowOffsets

Typ: _Field_size_(DimensionCount) const UINT*

Ein Array, das den Anfang (in Elementen) des Eingabefensters in jeder Dimension enthält. Werte im Array müssen die Einschränkung erfüllen. InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowSizes

Typ: _Field_size_(DimensionCount) const UINT*

Ein Array, das die Ausdehnung (in Elementen) des Eingabefensters in jeder Dimension enthält. Werte im Array müssen die Einschränkung erfüllen. InputWindowOffsets[i] + InputWindowSizes[i] <= InputTensor.Sizes[i]

InputWindowStrides

Typ: _Field_size_(DimensionCount) const UINT*

Ein Array, das den Schritt des Slices entlang jeder Dimension des Eingabe tensors in -Elementen enthält. Die Größe der Stride gibt an, wie viele Elemente beim Kopieren innerhalb des Eingabefensters erweitert werden sollen. Das Vorzeichen des Schritts bestimmt, ob Elemente beginnend am Anfang des Fensters (positiver Schritt) oder am Ende des Fensters (negativer Schritt) kopiert werden. Strides darf nicht 0 sein.

Beispiele

In den folgenden Beispielen wird derselbe Eingabe tensor verwendet.

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

Beispiel 1: Gestriertes Slice mit positiven Schritten

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

Die kopierten Elemente werden wie folgt berechnet.

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

Beispiel 2: Strided slice with negative strides

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

Denken Sie daran, dass Dimensionen mit negativen Fensterschritten am Ende des Eingabefensters für diese Dimension kopiert werden; Dies erfolgt durch Hinzufügen InputWindowSize[i] - 1 zum Fensteroffset. Dimensionen mit positiver Schritt beginnen einfach bei InputWindowOffset[i].

  • Achse 0 (+1 Fensterschritt) beginnt mit dem Kopieren von .InputWindowOffsets[0] = 0
  • Achse 1 (+1 Fensterschritt) beginnt mit dem Kopieren von InputWindowOffsets[1] = 0.
  • Achse 2 (-2 Fensterschritt) beginnt mit dem Kopieren von InputWindowOffsets[2] + InputWindowSizes[0] - 1 = 0 + 4 - 1 = 3.
  • Achse 3 (+2 Fensterschritt) beginnt mit dem Kopieren von InputWindowOffsets[3] = 1.

Die kopierten Elemente werden wie folgt berechnet.

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

Hinweise

Dieser Operator ähnelt DML_SLICE_OPERATOR_DESC, unterscheidet sich jedoch in zwei wichtigen Punkten.

  • Segmentschritte können negativ sein, was das Umkehren von Werten entlang von Dimensionen ermöglicht.
  • Die Größen des Eingabefensters sind nicht unbedingt identisch mit den Ausgabe tensorgrößen.

Verfügbarkeit

Dieser Operator wurde in DML_FEATURE_LEVEL_2_1eingeführt.

Tensoreinschränkungen

InputTensor und OutputTensor müssen über denselben DataType und DimensionCount verfügen.

Tensorunterstützung

DML_FEATURE_LEVEL_4_1 und höher

Tensor Variante Unterstützte Dimensionsanzahl Unterstützte Datentypen
InputTensor Eingabe 1 bis 8 FLOAT64, FLOAT32, FLOAT16, INT64, INT32, INT16, INT8, UINT64, UINT32, UINT16, UINT8
OutputTensor Ausgabe 1 bis 8 FLOAT64, FLOAT32, FLOAT16, INT64, INT32, INT16, INT8, UINT64, UINT32, UINT16, UINT8

DML_FEATURE_LEVEL_3_0 und höher

Tensor Variante Unterstützte Dimensionsanzahl Unterstützte Datentypen
InputTensor Eingabe 1 bis 8 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8
OutputTensor Ausgabe 1 bis 8 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8

DML_FEATURE_LEVEL_2_1 und höher

Tensor Variante Unterstützte Dimensionsanzahl Unterstützte Datentypen
InputTensor Eingabe 4 bis 5 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8
OutputTensor Ausgabe 4 bis 5 FLOAT32, FLOAT16, INT32, INT16, INT8, UINT32, UINT16, UINT8

Anforderungen

Anforderung Wert
Unterstützte Mindestversion (Client) Windows 10 Build 20348
Unterstützte Mindestversion (Server) Windows 10 Build 20348
Kopfzeile directml.h